Imported from libpng-0.89c.tar

ansi2knr.c

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

build.bat

@@ -0,0 +1,2 @@
+make -fmakefile.bor -B -DMODEL=m %1 %2 %3 libpng >buildm.out
+make -fmakefile.bor -B -DMODEL=l %1 %2 %3 libpng >buildl.out

descrip.mms

@@ -0,0 +1,51 @@
+
+cc_defs = /inc=$(ZLIBSRC)
+c_deb = 
+
+.ifdef __DECC__
+pref = /prefix=all
+.endif
+
+
+
+OBJS = png.obj, pngrcb.obj, pngrutil.obj, pngtrans.obj, pngwutil.obj,\
+	pngread.obj, pngmem.obj, pngwrite.obj, pngrtran.obj, pngwtran.obj,\
+	pngrio.obj, pngwio.obj, pngerror.obj, pngpread.obj
+
+
+CFLAGS= $(C_DEB) $(CC_DEFS) $(PREF)
+
+all : pngtest.exe libpng.olb
+		@ write sys$output " pngtest available"
+
+libpng.olb : libpng.olb($(OBJS))
+	@ write sys$output " Libpng available"
+
+
+pngtest.exe : pngtest.obj libpng.olb
+              link pngtest,libpng.olb/lib,$(ZLIBSRC)libz.olb/lib
+
+test : pngtest.exe
+   run pngtest
+
+clean :
+	delete *.obj;*,*.exe;*
+
+
+# Other dependencies.
+png.obj : png.h, pngconf.h
+pngpread.obj : png.h, pngconf.h
+pngrcb.obj : png.h, pngconf.h
+pngread.obj : png.h, pngconf.h
+pngrtran.obj : png.h, pngconf.h
+pngrutil.obj : png.h, pngconf.h
+pngerror.obj : png.h, pngconf.h
+pngmem.obj : png.h, pngconf.h
+pngrio.obj : png.h, pngconf.h
+pngwio.obj : png.h, pngconf.h
+pngtest.obj : png.h, pngconf.h
+pngtrans.obj : png.h, pngconf.h
+pngwrite.obj : png.h, pngconf.h
+pngwtran.obj : png.h, pngconf.h
+pngwutil.obj : png.h, pngconf.h
+

example.c

@@ -40,7 +40,7 @@ int check_png(char * file_name)
 void read_png(char *file_name)
 {
    FILE *fp;
-	png_structp png_ptr;
+   png_structp png_ptr;
    png_infop info_ptr;
 
    /* open the file */
@@ -48,77 +48,77 @@ void read_png(char *file_name)
    if (!fp)
       return;
 
-   /* allocate the necessary structures */
-   png_ptr = malloc(sizeof (png_struct));
+   /* Create and initialize the png_struct with the desired error handler
+      functions.  If you want to use the default stderr and longjump method,
+      you can supply NULL for the last three parameters.  We also check that
+      the header file is compatible with the library version.
+    */
+   png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+      (void *)user_error_ptr, user_error_fn, user_warning_fn);
+
    if (!png_ptr)
    {
       fclose(fp);
       return;
    }
 
-   info_ptr = malloc(sizeof (png_info));
+   info_ptr = png_create_info_struct();
    if (!info_ptr)
    {
       fclose(fp);
-      free(png_ptr);
+      png_destroy_read_struct(&png_ptr,  (png_infopp)NULL, (png_infopp)NULL);
       return;
    }
 
-   /* set error handling */
+   /* set error handling if you are using the setjmp/longjmp method */
    if (setjmp(png_ptr->jmpbuf))
    {
-      png_read_destroy(png_ptr, info_ptr, (png_info *)0);
+      /* Free all of the memory associated with the png_ptr and info_ptr */
+      png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
       fclose(fp);
-      free(png_ptr);
-      free(info_ptr);
       /* If we get here, we had a problem reading the file */
       return;
    }
 
-   /* initialize the structures, info first for error handling */
-   png_info_init(info_ptr);
-   png_read_init(png_ptr);
-
    /* set up the input control if you are using standard C streams */
    png_init_io(png_ptr, fp);
 
-	/* if you are using replacement read functions, here you would call */
-	png_set_read_fn(png_ptr, (void *)io_ptr, user_read_fn);
-	/* where io_ptr is a structure you want available to the callbacks */
+   /* 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 */
 
-	/* if you are using replacement message functions, here you would call */
-	png_set_message_fn(png_ptr, (void *)msg_ptr, user_error_fn, user_warning_fn);
-	/* where msg_ptr is a structure you want available to the callbacks */
+   /* read the file information */
+   png_read_info(png_ptr, info_ptr);
 
-	/* read the file information */
-	png_read_info(png_ptr, info_ptr);
-
-	/* set up the transformations you want.  Note that these are
+   /* set up the transformations you want.  Note that these are
       all optional.  Only call them if you want them */
 
-   /* expand paletted colors into true rgb */
+   /* expand paletted colors into true RGB triplets */
    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       png_set_expand(png_ptr);
 
    /* expand grayscale images to the full 8 bits */
-   if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
-      info_ptr->bit_depth < 8)
+   if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY && info_ptr->bit_depth < 8)
       png_set_expand(png_ptr);
 
-   /* expand images with transparency to full alpha channels */
+   /* expand paletted or RGB images with transparency to full alpha channels
+    * so the data will be available as RGBA quartets */
    if (info_ptr->valid & PNG_INFO_tRNS)
       png_set_expand(png_ptr);
 
    /* Set the background color to draw transparent and alpha
-		images over */
+      images over.  It is possible to set the red, green, and blue
+      components directly for paletted images. */
+
    png_color_16 my_background;
 
    if (info_ptr->valid & PNG_INFO_bKGD)
       png_set_background(png_ptr, &(info_ptr->background),
-			PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
-	else
-		png_set_background(png_ptr, &my_background,
-         PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+                         PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+   else
+      png_set_background(png_ptr, &my_background,
+                         PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
 
    /* tell libpng to handle the gamma conversion for you */
    if (info_ptr->valid & PNG_INFO_gAMA)
@@ -126,18 +126,17 @@ void read_png(char *file_name)
    else
       png_set_gamma(png_ptr, screen_gamma, 0.45);
 
-   /* tell libpng to strip 16 bit depth files down to 8 bits */
+   /* tell libpng to strip 16 bit/color files down to 8 bits/color */
    if (info_ptr->bit_depth == 16)
-		png_set_strip_16(png_ptr);
+      png_set_strip_16(png_ptr);
 
-   /* dither rgb files down to 8 bit palettes & reduce palettes
+   /* dither rgb files down to 8 bit palette & reduce palettes
       to the number of colors available on your screen */
    if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
    {
       if (info_ptr->valid & PNG_INFO_PLTE)
-         png_set_dither(png_ptr, info_ptr->palette,
-            info_ptr->num_palette, max_screen_colors,
-               info_ptr->histogram);
+         png_set_dither(png_ptr, info_ptr->palette, info_ptr->num_palette,
+                        max_screen_colors, info_ptr->histogram);
       else
       {
          png_color std_color_cube[MAX_SCREEN_COLORS] =
@@ -146,11 +145,10 @@ void read_png(char *file_name)
          png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
             MAX_SCREEN_COLORS, NULL);
       }
-	}
+   }
 
-   /* invert monocrome files */
-   if (info_ptr->bit_depth == 1 &&
-      info_ptr->color_type == PNG_COLOR_GRAY)
+   /* invert monocrome files to have 0 as white and 1 as black */
+   if (info_ptr->bit_depth == 1 && info_ptr->color_type == PNG_COLOR_GRAY)
       png_set_invert(png_ptr);
 
    /* shift the pixels down to their true bit depth */
@@ -158,34 +156,29 @@ void read_png(char *file_name)
       info_ptr->bit_depth > info_ptr->sig_bit)
       png_set_shift(png_ptr, &(info_ptr->sig_bit));
 
-   /* pack pixels into bytes */
+   /* pack multiple pixels with bit depths of 1, 2, and 4 into bytes
+      (useful only for paletted and grayscale images) */
    if (info_ptr->bit_depth < 8)
       png_set_packing(png_ptr);
 
    /* flip the rgb pixels to bgr */
    if (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
-		info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
       png_set_bgr(png_ptr);
 
    /* swap bytes of 16 bit files to least significant bit first */
    if (info_ptr->bit_depth == 16)
       png_set_swap(png_ptr);
 
-   /* add a filler byte to rgb files */
-   if (info_ptr->bit_depth == 8 &&
-      info_ptr->color_type == PNG_COLOR_TYPE_RGB)
+   /* add a filler byte to RGB files (before or after each RGB triplet) */
+   if (info_ptr->bit_depth == 8 && info_ptr->color_type == PNG_COLOR_TYPE_RGB)
       png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
 
    /* turn on interlace handling if you are not using png_read_image() */
-   if (info_ptr->interlace_type)
-      number_passes = png_set_interlace_handling(png_ptr);
-   else
-      number_passes = 1;
+   number_passes = png_set_interlace_handling(png_ptr);
 
-	/* optional call to update palette with transformations */
-   png_start_read_image(png_ptr);
-
-   /* optional call to update the info structure */
+   /* optional call to gamma correct and add the background to the palette
+      and update info structure. */
    png_read_update_info(png_ptr, info_ptr);
 
    /* allocate the memory to hold the image using the fields
@@ -193,6 +186,12 @@ void read_png(char *file_name)
 
    /* the easiest way to read the image */
    png_bytep row_pointers[height];
+
+   for (row = 0; row < height; row++)
+   {
+     row_pointers[row] = malloc(info_ptr->rowbytes);
+   }
+
    png_read_image(png_ptr, row_pointers);
 
    /* the other way to read images - deal with interlacing */
@@ -200,7 +199,7 @@ void read_png(char *file_name)
    for (pass = 0; pass < number_passes; pass++)
    {
       /* Read the image using the "sparkle" effect. */
-		png_read_rows(png_ptr, row_pointers, NULL, number_of_rows);
+      png_read_rows(png_ptr, row_pointers, NULL, number_of_rows);
 
       /* If you are only reading on row at a time, this works */
       for (y = 0; y < height; y++)
@@ -216,16 +215,11 @@ void read_png(char *file_name)
          so here */
    }
 
-   /* read the rest of the file, getting any additional chunks
-      in info_ptr */
-	png_read_end(png_ptr, info_ptr);
+   /* read the rest of the file, getting any additional chunks in info_ptr */
+   png_read_end(png_ptr, info_ptr);
 
    /* clean up after the read, and free any memory allocated */
-   png_read_destroy(png_ptr, info_ptr, (png_infop)0);
-
-   /* free the structures */
-   free(png_ptr);
-   free(info_ptr);
+   png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
 
    /* close the file */
    fclose(fp);
@@ -236,176 +230,179 @@ void read_png(char *file_name)
 
 /* progressively read a file */
 
-/* these will normally not be global unless you are only
-	reading in one image at a time */
-png_structp png_ptr;
-png_infop info_ptr;
-
 int
-initialize_png_reader()
+initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
 {
-	png_ptr = malloc(sizeof (png_struct));
-	if (!png_ptr)
-		return -1;
-	info_ptr = malloc(sizeof (png_info));
-	if (!info_ptr)
-	{
-		free(png_ptr);
-		return -1;
-	}
+   /* Create and initialize the png_struct with the desired error handler
+      functions.  If you want to use the default stderr and longjump method,
+      you can supply NULL for the last three parameters.  We also check that
+      the library version is compatible in case we are using dynamically
+      linked libraries.
+    */
+   *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+       (void *)user_error_ptr, user_error_fn, user_warning_fn);
 
-	if (setjmp(png_ptr->jmpbuf))
-	{
-		png_read_destroy(png_ptr, info_ptr, (png_info *)0);
-		/* free pointers before returning, if necessary */
-		free(png_ptr);
-		free(info_ptr);
-		return -1;
-	}
+   if (! *png_ptr)
+   {
+      *info_ptr = NULL;
+      return ERROR;
+   }
 
-	png_info_init(info_ptr);
-	png_read_init(png_ptr);
+   *info_ptr = png_create_info_struct(png_ptr);
 
-	/* this one's new.  You will need to provide all three
-		function callbacks, even if you aren't using them all.
-		You can put a void pointer in place of the NULL, and
-		retrieve the pointer from inside the callbacks using
-		the function png_get_progressive_ptr(png_ptr); */
-	png_set_progressive_read_fn(png_ptr, NULL,
-		info_callback, row_callback, end_callback);
+   if (! *info_ptr)
+   {
+      png_destroy_read_struct(png_ptr, info_ptr, (png_infopp)NULL);
+      return ERROR;
+   }
 
-	return 0;
+   if (setjmp((*png_ptr)->jmpbuf))
+   {
+      png_destroy_read_struct(png_ptr, info_ptr, (png_infopp)NULL);
+      return ERROR;
+   }
+
+   /* this one's new.  You will need to provide all three
+      function callbacks, even if you aren't using them all.
+      These functions shouldn't be dependent on global or
+      static variables if you are decoding several images
+      simultaneously.  You should store stream specific data
+      in a separate struct, given as the second parameter,
+      and retrieve the pointer from inside the callbacks using
+      the function png_get_progressive_ptr(png_ptr). */
+   png_set_progressive_read_fn(*png_ptr, (void *)stream_data,
+      info_callback, row_callback, end_callback);
+
+   return OK;
 }
 
 int
-process_data(png_bytep buffer, png_uint_32 length)
+process_data(png_structp *png_ptr, png_infop *info_ptr,
+   png_bytep buffer, png_uint_32 length)
 {
-	if (setjmp(png_ptr->jmpbuf))
-	{
-		png_read_destroy(png_ptr, info_ptr, (png_info *)0);
-		free(png_ptr);
-		free(info_ptr);
-		return -1;
-	}
+   if (setjmp((*png_ptr)->jmpbuf))
+   {
+      /* Free the png_ptr and info_ptr memory on error */
+      png_destroy_read_struct(png_ptr, info_ptr, (png_infopp)NULL);
+      return ERROR;
+   }
 
-	/* this one's new also.  Simply give it a chunk of data
-		from the file stream (in order, of course).  On Segmented
-		machines, don't give it any more then 64K.  The library
-		seems to run fine with sizes of 4K, although you can give
-		it much less if necessary (I assume you can give it chunks
-		of 1 byte, but I haven't tried less then 256 bytes yet).
-		When this function returns, you may want to display any
-		rows that were generated in the row callback. */
-	png_process_data(png_ptr, info_ptr, buffer, length);
-	return 0;
+   /* this one's new also.  Simply give it chunks of data as
+      they arrive from the data stream (in order, of course).
+      On Segmented machines, don't give it any more than 64K.
+      The library seems to run fine with sizes of 4K, although
+      you can give it much less if necessary (I assume you can
+      give it chunks of 1 byte, but I haven't tried with less
+      than 256 bytes yet).  When this function returns, you may
+      want to display any rows that were generated in the row
+      callback, if you aren't already displaying them there. */
+   png_process_data(*png_ptr, *info_ptr, buffer, length);
+   return OK;
 }
 
 info_callback(png_structp png_ptr, png_infop info)
 {
-/*	do any setup here, including setting any of the transformations
-	mentioned in the Reading PNG files section.  For now, you _must_
-	call either png_start_read_image() or png_read_update_info()
-	after all the transformations are set (even if you don't set
-	any).  You may start getting rows before png_process_data()
-	returns, so this is your last chance to prepare for that. */
+/* do any setup here, including setting any of the transformations
+   mentioned in the Reading PNG files section.  For now, you _must_
+   call either png_start_read_image() or png_read_update_info()
+   after all the transformations are set (even if you don't set
+   any).  You may start getting rows before png_process_data()
+   returns, so this is your last chance to prepare for that. */
 }
 
 row_callback(png_structp png_ptr, png_bytep new_row,
-	png_uint_32 row_num, int pass)
+   png_uint_32 row_num, int pass)
 {
-/*	this function is called for every row in the image.  If the
-	image is interlacing, and you turned on the interlace handler,
-	this function will be called for every row in every pass.
-	Some of these rows will not be changed from the previous pass.
-	When the row is not changed, the new_row variable will be NULL.
-	The rows and passes are called in order, so you don't really
-	need the row_num and pass, but I'm supplying them because it
-	may make your life easier.
+/* this function is called for every row in the image.  If the
+   image is interlacing, and you turned on the interlace handler,
+   this function will be called for every row in every pass.
+   Some of these rows will not be changed from the previous pass.
+   When the row is not changed, the new_row variable will be NULL.
+   The rows and passes are called in order, so you don't really
+   need the row_num and pass, but I'm supplying them because it
+   may make your life easier.
 
-	For the non-NULL rows of interlaced images, you must call
-	png_progressive_combine_row() passing in the row and the
-	old row.  You can call this function for NULL rows (it will
-	just return) and for non-interlaced images (it just does the
-	memcpy for you) if it will make the code easier.  Thus, you
-	can just do this for all cases: */
+   For the non-NULL rows of interlaced images, you must call
+   png_progressive_combine_row() passing in the row and the
+   old row.  You can call this function for NULL rows (it will
+   just return) and for non-interlaced images (it just does the
+   memcpy for you) if it will make the code easier.  Thus, you
+   can just do this for all cases: */
 
-	png_progressive_combine_row(png_ptr, old_row, new_row);
+   png_progressive_combine_row(png_ptr, old_row, new_row);
 
-/*	where old_row is what was displayed for previous rows.  Note
-	that the first pass (pass == 0 really) will completely cover
-	the old row, so the rows do not have to be initialized.  After
-	the first pass (and only for interlaced images), you will have
-	to pass the current row, and the function will combine the
-	old row and the new row. */
+/* where old_row is what was displayed for previous rows.  Note
+   that the first pass (pass == 0 really) will completely cover
+   the old row, so the rows do not have to be initialized.  After
+   the first pass (and only for interlaced images), you will have
+   to pass the current row, and the function will combine the
+   old row and the new row. */
 }
 
 end_callback(png_structp png_ptr, png_infop info)
 {
-/*	this function is called when the whole image has been read,
-	including any chunks after the image (up to and including
-	the IEND).  You will usually have the same info chunk as you
-	had in the header, although some data may have been added
-	to the comments and time fields.
+/* this function is called when the whole image has been read,
+   including any chunks after the image (up to and including
+   the IEND).  You will usually have the same info chunk as you
+   had in the header, although some data may have been added
+   to the comments and time fields.
 
-	Most people won't do much here, perhaps setting a flag that
-	marks the image as finished. */
+   Most people won't do much here, perhaps setting a flag that
+   marks the image as finished. */
 }
 
 /* write a png file */
 void write_png(char *file_name, ... other image information ...)
 {
    FILE *fp;
-	png_structp png_ptr;
-	png_infop info_ptr;
+   png_structp png_ptr;
+   png_infop info_ptr;
 
    /* open the file */
    fp = fopen(file_name, "wb");
    if (!fp)
       return;
 
-   /* allocate the necessary structures */
-   png_ptr = malloc(sizeof (png_struct));
+   /* Create and initialize the png_struct with the desired error handler
+      functions.  If you want to use the default stderr and longjump method,
+      you can supply NULL for the last three parameters.  We also check that
+      the library version is compatible in case we are using dynamically
+      linked libraries.
+    */
+   png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+      (void *)user_error_ptr, user_error_fn, user_warning_fn);
+
    if (!png_ptr)
    {
       fclose(fp);
       return;
    }
 
-   info_ptr = malloc(sizeof (png_info));
+   info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
    {
       fclose(fp);
-      free(png_ptr);
+      png_destroy_write_struct(&png_ptr,  (png_infopp)NULL);
       return;
    }
 
    /* set error handling */
-	if (setjmp(png_ptr->jmpbuf))
+   if (setjmp(png_ptr->jmpbuf))
    {
-      png_write_destroy(png_ptr);
-      fclose(fp);
-      free(png_ptr);
-      free(info_ptr);
       /* If we get here, we had a problem reading the file */
+      fclose(fp);
+      png_destroy_write_struct(&png_ptr,  (png_infopp)NULL);
       return;
    }
 
-   /* initialize the structures */
-   png_info_init(info_ptr);
-   png_write_init(png_ptr);
-
    /* set up the output control if you are using standard C streams */
    png_init_io(png_ptr, fp);
 
-	/* if you are using replacement write functions, here you would call */
-	png_set_write_fn(png_ptr, (void *)io_ptr, user_write_fn, user_flush_fn);
-	/* where io_ptr is a structure you want available to the callbacks */
+   /* if you are using replacement message functions, here you would call */
+   png_set_message_fn(png_ptr, (void *)msg_ptr, user_error_fn, user_warning_fn);
+   /* where msg_ptr is a structure you want available to the callbacks */
 
-	/* if you are using replacement message functions, here you would call */
-	png_set_message_fn(png_ptr, (void *)msg_ptr, user_error_fn, user_warning_fn);
-	/* where msg_ptr is a structure you want available to the callbacks */
-
-	/* set the file information here */
+   /* set the file information here */
    info_ptr->width = ;
    info_ptr->height = ;
    etc.
@@ -418,23 +415,23 @@ void write_png(char *file_name, ... other image information ...)
 
    /* optional significant bit chunk */
    info_ptr->valid |= PNG_INFO_sBIT;
-	/* if we are dealing with a grayscale image then */
-	info_ptr->sig_bit.gray = true_bit_depth;
-	/* otherwise, if we are dealing with a color image then */
-	info_ptr->sig_bit.red = true_red_bit_depth;
-	info_ptr->sig_bit.green = true_green_bit_depth;
-	info_ptr->sig_bit.blue = true_blue_bit_depth;
-	/* if the image has an alpha channel then */
+   /* if we are dealing with a grayscale image then */
+   info_ptr->sig_bit.gray = true_bit_depth;
+   /* otherwise, if we are dealing with a color image then */
+   info_ptr->sig_bit.red = true_red_bit_depth;
+   info_ptr->sig_bit.green = true_green_bit_depth;
+   info_ptr->sig_bit.blue = true_blue_bit_depth;
+   /* if the image has an alpha channel then */
    info_ptr->sig_bit.alpha = true_alpha_bit_depth;
   
-	/* optional gamma chunk is strongly suggested if you have any guess
-	   as to the correct gamma of the image */
-	info_ptr->valid |= PNG_INFO_gAMA;
+   /* optional gamma chunk is strongly suggested if you have any guess
+      as to the correct gamma of the image */
+   info_ptr->valid |= PNG_INFO_gAMA;
    info_ptr->gamma = gamma;
 
-   /* other optional chunks */
+   /* other optional chunks like cHRM, bKGD, tRNS, tEXt, tIME, oFFs, pHYs, */
 
-   /* write the file information */
+   /* write the file header information */
    png_write_info(png_ptr, info_ptr);
 
    /* set up the transformations you want.  Note that these are
@@ -466,8 +463,10 @@ void write_png(char *file_name, ... other image information ...)
    else
       number_passes = 1;
 
-   /* the easiest way to write the image */
-   png_bytep row_pointers[height];
+   /* the easiest way to write the image (you may choose to allocate the
+      memory differently, however) */
+   png_byte row_pointers[height][width];
+
    png_write_image(png_ptr, row_pointers);
 
    /* the other way to write the image - deal with interlacing */
@@ -485,19 +484,23 @@ void write_png(char *file_name, ... other image information ...)
       }
    }
 
+   /* You can write optional chunks like tEXt, tIME at the end as well.
+    * Note that if you wrote tEXt or zTXt chunks before the image, and
+    * you aren't writing out more at the end, you have to set
+    * info_ptr->num_text = 0 or they will be written out again.
+    */
+
    /* write the rest of the file */
    png_write_end(png_ptr, info_ptr);
 
-   /* clean up after the write, and free any memory allocated */
-   png_write_destroy(png_ptr);
-
    /* if you malloced the palette, free it here */
    if (info_ptr->palette)
       free(info_ptr->palette);
 
-   /* free the structures */
-   free(png_ptr);
-   free(info_ptr);
+   /* if you allocated any text comments, free them here */
+
+   /* clean up after the write, and free any memory allocated */
+   png_destroy_write_struct(&png_ptr,  (png_infopp)NULL);
 
    /* close the file */
    fclose(fp);

makefile

@@ -2,19 +2,19 @@
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
-CC=gcc
-CFLAGS=-I../zlib -O2 -Wall
+CC=cc
+CFLAGS=-I../zlib -O
 LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
 
-RANLIB=ranlib
-#RANLIB=echo
+#RANLIB=ranlib
+RANLIB=echo
 
 # where make install puts libpng.a and png.h
-prefix=/home/munet-d2/sun/local
+prefix=/usr/local
 
 OBJS = png.o pngrcb.o pngrutil.o pngtrans.o pngwutil.o \
-	pngread.o pngio.o pngwrite.o pngrtran.o pngwtran.o \
-   pngmem.o pngerror.o pngpread.o
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
 
 all: libpng.a pngtest
 
@@ -31,12 +31,11 @@ test: pngtest
 install: libpng.a
 	-@mkdir $(prefix)/include
 	-@mkdir $(prefix)/lib
-	cp png.h pngconf.h $(prefix)/include
-	rcp png.h pngconf.h vlsi:bin/include
+	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
-	rcp libpng.a vlsi:bin/lib
 	chmod 644 $(prefix)/lib/libpng.a
 
 clean:
@@ -46,7 +45,8 @@ clean:
 
 png.o: png.h pngconf.h
 pngerror.o: png.h pngconf.h
-pngio.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
 pngmem.o: png.h pngconf.h
 pngrcb.o: png.h pngconf.h
 pngread.o: png.h pngconf.h

makefile.aco

@@ -0,0 +1,115 @@
+# makefile for libpng on Acorn RISCOS
+# Project:   libpng
+
+
+# Toolflags:
+CCflags = -c -depend !Depend -IC:,Zlib: -g -throwback  -DRISCOS  -fnah 
+C++flags = -c -depend !Depend -IC: -throwback
+Linkflags = -aif -c++ -o $@
+ObjAsmflags = -throwback -NoCache -depend !Depend
+CMHGflags = 
+LibFileflags = -c -o $@ 
+Squeezeflags = -o $@
+
+
+# Final targets:
+@.libpng-lib:   @.o.png @.o.pngerror @.o.pngrio @.o.pngwio @.o.pngmem \
+        @.o.pngpread @.o.pngrcb @.o.pngread @.o.pngrtran @.o.pngrutil \
+        @.o.pngtrans @.o.pngwrite @.o.pngwtran @.o.pngwutil
+        LibFile $(LibFileflags) @.o.png @.o.pngerror @.o.pngrio @.o.pngwio \
+        @.o.pngmem @.o.pngpread @.o.pngrcb @.o.pngread @.o.pngrtran \
+        @.o.pngrutil @.o.pngtrans @.o.pngwrite @.o.pngwtran @.o.pngwutil 
+@.test:   @.tests.pngtest 
+        echo Please run "Test" in directory tests 
+@.tests.pngtest:   @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
+        Link $(Linkflags) @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib 
+
+
+# User-editable dependencies:
+.c.o:
+        cc $(ccflags) -o $@ $<
+
+
+# Static dependencies:
+@.o.example:   @.tests.c.example
+        cc $(ccflags) -o @.o.example @.tests.c.example 
+@.o.pngtest:   @.tests.c.pngtest
+        cc $(ccflags) -o @.o.pngtest @.tests.c.pngtest 
+
+
+# Dynamic dependencies:
+o.png:	c.png
+o.png:	h.png
+o.png:	Zlib:h.zlib
+o.png:	Zlib:h.zconf
+o.png:	h.pngconf
+o.pngerror:	c.pngerror
+o.pngerror:	h.png
+o.pngerror:	Zlib:h.zlib
+o.pngerror:	Zlib:h.zconf
+o.pngerror:	h.pngconf
+o.pngrio:	c.pngrio
+o.pngrio:	h.png
+o.pngrio:	Zlib:h.zlib
+o.pngrio:	Zlib:h.zconf
+o.pngrio:	h.pngconf
+o.pngwio:	c.pngwio
+o.pngwio:	h.png
+o.pngwio:	Zlib:h.zlib
+o.pngwio:	Zlib:h.zconf
+o.pngwio:	h.pngconf
+o.pngmem:	c.pngmem
+o.pngmem:	h.png
+o.pngmem:	Zlib:h.zlib
+o.pngmem:	Zlib:h.zconf
+o.pngmem:	h.pngconf
+o.pngpread:	c.pngpread
+o.pngpread:	h.png
+o.pngpread:	Zlib:h.zlib
+o.pngpread:	Zlib:h.zconf
+o.pngpread:	h.pngconf
+o.pngrcb:	c.pngrcb
+o.pngrcb:	h.png
+o.pngrcb:	Zlib:h.zlib
+o.pngrcb:	Zlib:h.zconf
+o.pngrcb:	h.pngconf
+o.pngread:	c.pngread
+o.pngread:	h.png
+o.pngread:	Zlib:h.zlib
+o.pngread:	Zlib:h.zconf
+o.pngread:	h.pngconf
+o.pngrtran:	c.pngrtran
+o.pngrtran:	h.png
+o.pngrtran:	Zlib:h.zlib
+o.pngrtran:	Zlib:h.zconf
+o.pngrtran:	h.pngconf
+o.pngrutil:	c.pngrutil
+o.pngrutil:	h.png
+o.pngrutil:	Zlib:h.zlib
+o.pngrutil:	Zlib:h.zconf
+o.pngrutil:	h.pngconf
+o.pngtrans:	c.pngtrans
+o.pngtrans:	h.png
+o.pngtrans:	Zlib:h.zlib
+o.pngtrans:	Zlib:h.zconf
+o.pngtrans:	h.pngconf
+o.pngwrite:	c.pngwrite
+o.pngwrite:	h.png
+o.pngwrite:	Zlib:h.zlib
+o.pngwrite:	Zlib:h.zconf
+o.pngwrite:	h.pngconf
+o.pngwtran:	c.pngwtran
+o.pngwtran:	h.png
+o.pngwtran:	Zlib:h.zlib
+o.pngwtran:	Zlib:h.zconf
+o.pngwtran:	h.pngconf
+o.pngwutil:	c.pngwutil
+o.pngwutil:	h.png
+o.pngwutil:	Zlib:h.zlib
+o.pngwutil:	Zlib:h.zconf
+o.pngwutil:	h.pngconf
+o.pngtest:	tests.c.pngtest
+o.pngtest:	h.png
+o.pngtest:	Zlib:h.zlib
+o.pngtest:	Zlib:h.zconf
+o.pngtest:	h.pngconf

makefile.ama

@@ -0,0 +1,42 @@
+# Commodore Amiga Makefile
+# makefile for libpng and SAS C V6.55 compiler
+# Copyright (C) 1995 Wolf Faust
+
+#compiler
+CC=sc
+#compiler flags
+# WARNING: a bug in V6.51 causes bad code with OPTGO
+#          So use V6.55 or set NOOPTGO!!!!!!!!!
+CFLAGS= NOSTKCHK PARMS=REG OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL\
+        OPTLOOP OPTRDEP=4 OPTDEP=4 OPTCOMP=4 DEFINE=PNG_INTERNAL
+#linker flags
+LDFLAGS= SD ND BATCH
+#link libs
+LDLIBS= libpng.lib libgz.lib LIB:scm.lib LIB:sc.lib Lib:amiga.lib
+# linker
+LN= slink
+# file deletion command
+RM= delete quiet
+# library (.lib) file creation command
+AR= oml
+# make directory command
+MKDIR= makedir
+
+OBJS = png.o pngrcb.o pngrutil.o pngtrans.o pngwutil.o pngpread.o \
+pngread.o pngerror.o pngwrite.o pngrtran.o pngwtran.o pngrio.o pngwio.o pngmem.o
+
+all: libpng.lib pngtest
+
+libpng.lib: $(OBJS)
+-$(RM) libpng.lib
+$(AR) libpng.lib r $(OBJS)
+
+pngtest: pngtest.o libpng.lib
+$(LN) <WITH <
+$(LDFLAGS)
+TO pngtest
+FROM LIB:c.o pngtest.o
+LIB $(LDLIBS)
+<
+
+

makefile.atr

@@ -0,0 +1,31 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+# modified for LC56/ATARI assumes libz.lib is in same dir and uses default
+# rules for library management
+#
+CFLAGS=-I..\zlib -O
+LBR = png.lib
+LDFLAGS=-lpng -lz -lm
+
+# where make install puts libpng.a and png.h
+
+OBJS = $(LBR)(png.o) $(LBR)(pngrcb.o) $(LBR)(pngrutil.o)\
+	$(LBR)(pngtrans.o) $(LBR)(pngwutil.o)\
+	$(LBR)(pngread.o) $(LBR)(pngerror.o) $(LBR)(pngwrite.o)\
+	$(LBR)(pngrtran.o) $(LBR)(pngwtran.o)\
+	$(LBR)(pngmem.o) $(LBR)(pngrio.o) $(LBR)(pngwio.o) $(LBR)(pngpread.o)
+
+all: $(LBR) pngtest.ttp
+
+$(LBR): $(OBJS)
+
+pngtest.ttp: pngtest.o $(LBR)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o$@ pngtest.o
+
+install: libpng.a
+	-@mkdir $(prefix)/include
+	-@mkdir $(prefix)/lib
+	cp png.h $(prefix)/include
+	cp pngconf.h $(prefix)/include
+	chmod 644 $(prefix)/include/p

makefile.bor

@@ -0,0 +1,165 @@
+# Makefile for libpng
+# Borland C++ 4.5 (Note: All modules are compiled in C mode)
+# Will work with C++ 4.02 also
+# To build the library, do: 
+#       "make -fmakefile.bor -DMODEL=m"
+# or:   "make -fmakefile.bor -DMODEL=l"
+#
+# ------------- Borland C++ 4.5 -------------
+
+### Absolutely necessary for this makefile to work
+.AUTODEPEND
+
+## Useful user options
+
+# Usually defined in builtins.mak or the environment
+# Currently unused.
+!ifndef BCROOT
+BCROOT=N:\BC45
+!endif
+
+# Where zlib.h and zconf.h and zlib.lib are
+ZLIB_PATH=..\zlib
+
+!ifndef MODEL
+MODEL=l
+!endif
+
+#TARGET_CPU=3
+# 2 = 286, 3 = 386, etc.
+!ifndef TARGET_CPU
+TARGET_CPU=2
+!endif
+
+
+# Use this if you don't want Borland's fancy exception handling.
+NOEHLIB=noeh$(MODEL).lib
+
+!ifdef DEBUG
+CDEBUG=-v
+LDEBUG=-v
+!else
+CDEBUG=
+LDEBUG=
+!endif
+
+# STACKOFLOW=1
+!ifdef STACKOFLOW
+CDEBUG=$(CDEBUG) -N
+LDEBUG=$(LDEBUG) -N
+!endif
+
+
+## Compiler, linker, and lib stuff
+CC=bcc
+LD=bcc
+LIB=tlib
+
+MODELARG=-m$(MODEL)
+
+# -X- turns on dependency generation in the object file
+# -w  sets all warnings on
+# -O2 optimize for speed
+# -Z  global optimization
+CFLAGS=-O2 -Z -X- -w -I$(ZLIB_PATH) -$(TARGET_CPU) $(MODELARG) $(CDEBUG)
+
+# -M  generate map file
+LDFLAGS=-M $(LDEBUG)
+
+O=obj
+
+## variables
+OBJS = \
+ png.$(O) \
+ pngerror.$(O) \
+ pngmem.$(O) \
+ pngpread.$(O) \
+ pngrcb.$(O) \
+ pngread.$(O) \
+ pngrio.$(O) \
+ pngrtran.$(O) \
+ pngrutil.$(O) \
+ pngtrans.$(O) \
+ pngwrite.$(O) \
+ pngwtran.$(O) \
+ pngwio.$(O) \
+ pngwutil.$(O)
+
+LIBOBJS = \
+ +png.$(O) \
+ +pngerror.$(O) \
+ +pngmem.$(O) \
+ +pngpread.$(O) \
+ +pngread.$(O) \
+ +pngrcb.$(O) \
+ +pngrio.$(O) \
+ +pngrtran.$(O) \
+ +pngrutil.$(O) \
+ +pngtrans.$(O) \
+ +pngwrite.$(O) \
+ +pngwtran.$(O) \
+ +pngwio.$(O)
+ +pngwutil.$(O)
+
+LIBNAME=libpng$(MODEL).lib
+
+
+## Implicit rules
+# Braces let make "batch" calls to the compiler,
+# 2 calls instead of 12; space is important.
+.c.obj:
+	$(CC) $(CFLAGS) -c {$*.c }
+
+.c.exe:
+	$(CC) $(CFLAGS) $(LDFLAGS) $*.c
+
+
+## Major targets
+libpng: $(LIBNAME)
+
+pngtest: pngtest$(MODEL).exe
+
+test:
+	pngtest$(MODEL)
+
+
+## Minor Targets
+
+png.obj: png.c
+pngrcb.obj: pngrcb.c
+pngread.obj: pngread.c
+pngpread.obj: pngpread.c
+pngrtran.obj: pngrtran.c
+pngrutil.obj: pngrutil.c
+pngerror.obj: pngerror.c
+pngmem.obj: pngmem.c
+pngrio.obj: pngrio.c
+pngwio.obj: pngwio.c
+pngtrans.obj: pngtrans.c
+pngwrite.obj: pngwrite.c
+pngwtran.obj: pngwtran.c
+pngwutil.obj: pngwutil.c
+
+
+$(LIBNAME): $(OBJS)
+	-del $(LIBNAME)
+        $(LIB) $(LIBNAME) @&&|
+$(LIBOBJS), libpng$(MODEL)
+|
+
+
+pngtest$(MODEL).obj: pngtest.c
+	$(CC) $(CFLAGS) -opngtest$(MODEL) -c pngtest.c
+
+pngtest$(MODEL).exe: pngtest$(MODEL).obj
+	$(CC) $(MODELARG) $(LDFLAGS) -L$(ZLIB_PATH) pngtest$(MODEL).obj $(LIBNAME) zlib$(MODEL).lib $(NOEHLIB)
+
+
+# Clean up anything else you want
+clean:
+	-del *.obj
+	-del *.lib
+	-del *.lst
+
+
+# End of makefile for libpng

makefile.dj2

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

makefile.elf

@@ -4,19 +4,19 @@
 
 CC=gcc
 CFLAGS=-I../zlib -O2 -Wall -fPIC
-LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+LDFLAGS=-L. -Wl,-rpath,. -L../zlib/ -Wl,-rpath,../zlib/ -lpng -lz -lm
 
 RANLIB=ranlib
 #RANLIB=echo
 
-PNGVER = 0.87
+PNGVER = 0.89
 
 # where make install puts libpng.a, libpng.so*, and png.h
 prefix=/usr/local
 
 OBJS = png.o pngrcb.o pngrutil.o pngtrans.o pngwutil.o \
-       pngread.o pngio.o pngwrite.o pngrtran.o pngwtran.o \
-       pngmem.o pngerror.o pngpread.o
+       pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+       pngwtran.o pngmem.o pngerror.o pngpread.o
 
 all: libpng.so pngtest
 
@@ -59,7 +59,8 @@ clean:
 
 png.o: png.h pngconf.h
 pngerror.o: png.h pngconf.h
-pngio.o: png.h pngconf.h
+pngrio.o: png.h pngconf.h
+pngwio.o: png.h pngconf.h
 pngmem.o: png.h pngconf.h
 pngrcb.o: png.h pngconf.h
 pngread.o: png.h pngconf.h

makefile.knr

@@ -0,0 +1,72 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=cc
+CFLAGS=-I../zlib -O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+# flags for ansi2knr
+ANSI2KNRFLAGS=
+
+RANLIB=ranlib
+#RANLIB=echo
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngrcb.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: ansi2knr libpng.a pngtest
+
+# general rule to allow ansi2knr to work
+.c.o:
+	./ansi2knr $*.c T$*.c
+	$(CC) $(CFLAGS) -c T$*.c
+	rm -f T$*.c $*.o
+	mv T$*.o $*.o
+
+ansi2knr: ansi2knr.c
+	$(CC) $(CFLAGS) $(ANSI2KNRFLAGS) -o ansi2knr ansi2knr.c
+
+libpng.a: ansi2knr $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a ansi2knr
+	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 ansi2knr
+
+# 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
+pngrcb.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngpread.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

makefile.mip

@@ -0,0 +1,61 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=cc
+CFLAGS=-I../zlib -O -systype sysv -DSYSV -w -Dmips
+#CFLAGS=-O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+
+#RANLIB=ranlib
+RANLIB=echo
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngrcb.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
+pngrcb.o: png.h pngconf.h
+pngread.o: png.h pngconf.h
+pngpread.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

makefile.msc

@@ -0,0 +1,81 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+# Assumes that zlib.lib, zconf.h, and zlib.h have been copied to ..\zlib
+
+# ------------- Microsoft C 5.1 and later -------------
+MODEL=-AL
+CFLAGS=-Oait -Gs -nologo -W2 $(MODEL) -I..\zlib
+#-Ox generates bad code with MSC 5.1
+CC=cl
+LD=link
+LDFLAGS=/e/st:0x1500/noe 
+O=.obj
+
+#uncomment next to put error messages in a file
+ERRFILE= >> pngerrs
+
+# variables
+OBJS1 = png$(O) pngrcb$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O) pngmem$(O) pngpread$(O)
+OBJS2 = pngread$(O) pngerror$(O) pngwrite$(O) pngrtran$(O) pngwtran$(O) pngrio$(O) pngwio$(O)
+
+all: libpng.lib
+
+png$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrcb$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngread$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngpread$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngerror$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngmem$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngrio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngtest$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngtrans$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwrite$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+pngwutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c $(ERRFILE)
+
+libpng.lib: $(OBJS1) $(OBJS2)
+        del libpng.lib
+	lib libpng $(OBJS1);
+	lib libpng $(OBJS2);
+
+pngtest.exe: pngtest.obj libpng.lib 
+	$(LD) $(LDFLAGS) pngtest.obj,,,libpng.lib ..\zlib\zlib.lib ;
+
+test: pngtest.exe
+	pngtest
+
+# End of makefile for libpng
+

makefile.std

@@ -0,0 +1,61 @@
+# makefile for libpng
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+# For conditions of distribution and use, see copyright notice in png.h
+
+CC=cc
+CFLAGS=-I../zlib -O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+
+#RANLIB=ranlib
+RANLIB=echo
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+
+OBJS = png.o pngrcb.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
+pngrcb.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
+

makefile.tc

@@ -0,0 +1,72 @@
+# Makefile for libpng
+# TurboC++ 3.0 (Note: All modules are compiled in C mode)
+
+# To use, do "make -fmakefile.tc"
+
+# ------------- Turbo C++ 3.0 -------------
+MODEL=-ml
+CFLAGS=-O2 -Z $(MODEL) -I..\zlib
+CC=tcc
+LD=tcc
+LIB=tlib
+LDFLAGS=$(MODEL)
+O=.obj
+
+# variables
+OBJS1 = png$(O) pngrcb$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O) pngmem$(O) pngpread$(O)
+OBJS2 = pngread$(O) pngerror$(O) pngwrite$(O) pngrtran$(O) pngwtran$(O) pngrio$(O) pngwio$(O)
+OBJSL1 = +png$(O) +pngrcb$(O) +pngrutil$(O) +pngtrans$(O) +pngwutil$(O) +pngmem$(O) +pngpread$(O)
+OBJSL2 = +pngread$(O) +pngerror$(O) +pngwrite$(O) +pngrtran$(O) +pngwtran$(O) +pngrio$(O) +pngwio$(O)
+
+all: libpng.lib
+
+png$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngrcb$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngread$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngpread$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngrtran$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngrutil$(O): png.h pngconf.h
+		  $(CC) -c $(CFLAGS) $*.c
+
+pngerror$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngmem$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngrio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwio$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngtest$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngtrans$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwrite$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwtran$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+pngwutil$(O): png.h pngconf.h
+        $(CC) -c $(CFLAGS) $*.c
+
+libpng.lib: $(OBJS1) $(OBJS2)
+        $(LIB) libpng +$(OBJSL1)
+        $(LIB) libpng +$(OBJSL2)
+
+# End of makefile for libpng

makevms.com

@@ -0,0 +1,123 @@
+$! make libpng under VMS
+$!
+$!
+$! Look for the compiler used
+$!
+$ zlibsrc = "[-.zlib]"
+$ ccopt="/include=''zlibsrc'"
+$ if f$getsyi("HW_MODEL").ge.1024
+$ then
+$  ccopt = "/prefix=all"+ccopt
+$  comp  = "__decc__=1"
+$  if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$ else
+$  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
+$   then
+$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$    if f$search("SYS$SYSTEM:VAXC.EXE").eqs.""
+$     then
+$      comp  = "__gcc__=1"
+$      CC :== GCC
+$     else
+$      comp = "__vaxc__=1"
+$     endif
+$   else
+$    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
+$    ccopt = "/decc/prefix=all"+ccopt
+$    comp  = "__decc__=1"
+$  endif
+$ endif
+$!
+$! Build the thing plain or with mms
+$!
+$ write sys$output "Compiling Libpng sources ..."
+$ if f$search("SYS$SYSTEM:MMS.EXE").eqs.""
+$  then
+$   dele pngtest.obj;*
+$   CALL MAKE png.OBJ "cc ''CCOPT' png" -
+                png.c png.h pngconf.h   
+$   CALL MAKE pngpread.OBJ "cc ''CCOPT' pngpread" -
+					 pngpread.c png.h pngconf.h
+$   CALL MAKE pngrcb.OBJ "cc ''CCOPT' pngrcb" -
+                pngrcb.c png.h pngconf.h
+$   CALL MAKE pngread.OBJ "cc ''CCOPT' pngread" -
+                pngread.c png.h pngconf.h
+$   CALL MAKE pngpread.OBJ "cc ''CCOPT' pngpread" -
+					 pngpread.c png.h pngconf.h
+$   CALL MAKE pngrtran.OBJ "cc ''CCOPT' pngrtran" -
+                pngrtran.c png.h pngconf.h
+$   CALL MAKE pngrutil.OBJ "cc ''CCOPT' pngrutil" -
+                pngrutil.c png.h pngconf.h
+$   CALL MAKE pngerror.OBJ "cc ''CCOPT' pngerror" -
+                pngerror.c png.h pngconf.h
+$   CALL MAKE pngmem.OBJ "cc ''CCOPT' pngmem" -
+                pngmem.c png.h pngconf.h
+$   CALL MAKE pngrio.OBJ "cc ''CCOPT' pngrio" -
+                pngrio.c png.h pngconf.h
+$   CALL MAKE pngwio.OBJ "cc ''CCOPT' pngwio" -
+                pngwio.c png.h pngconf.h
+$   CALL MAKE pngtrans.OBJ "cc ''CCOPT' pngtrans" -
+                pngtrans.c png.h pngconf.h
+$   CALL MAKE pngwrite.OBJ "cc ''CCOPT' pngwrite" -
+                pngwrite.c png.h pngconf.h
+$   CALL MAKE pngwtran.OBJ "cc ''CCOPT' pngwtran" -
+                pngwtran.c png.h pngconf.h
+$   CALL MAKE pngwutil.OBJ "cc ''CCOPT' pngwutil" -
+                pngwutil.c png.h pngconf.h
+$   write sys$output "Building Libpng ..."
+$   CALL MAKE libpng.OLB "lib/crea libpng.olb *.obj" *.OBJ
+$   write sys$output "Building pngtest..."
+$   CALL MAKE pngtest.OBJ "cc ''CCOPT' pngtest" -
+                pngtest.c png.h pngconf.h
+$   call make pngtest.exe - 
+                "LINK pngtest,libpng.olb/lib,''zlibsrc'libgz.olb/lib" - 
+                pngtest.obj libpng.olb
+$   write sys$output "Testing Libpng..."
+$   run pngtest
+$  else
+$   mms/macro=('comp',zlibsrc='zlibsrc')
+$  endif
+$ write sys$output "Libpng build completed"
+$ exit
+$!
+$!
+$MAKE: SUBROUTINE   !SUBROUTINE TO CHECK DEPENDENCIES
+$ V = 'F$Verify(0)
+$! P1 = What we are trying to make
+$! P2 = Command to make it
+$! P3 - P8  What it depends on
+$
+$ If F$Search(P1) .Eqs. "" Then Goto Makeit
+$ Time = F$CvTime(F$File(P1,"RDT"))
+$arg=3
+$Loop:
+$       Argument = P'arg
+$       If Argument .Eqs. "" Then Goto Exit
+$       El=0
+$Loop2:
+$       File = F$Element(El," ",Argument)
+$       If File .Eqs. " " Then Goto Endl
+$       AFile = ""
+$Loop3:
+$       OFile = AFile
+$       AFile = F$Search(File)
+$       If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl
+$       If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit
+$       Goto Loop3
+$NextEL:
+$       El = El + 1
+$       Goto Loop2
+$EndL:
+$ arg=arg+1
+$ If arg .Le. 8 Then Goto Loop
+$ Goto Exit
+$
+$Makeit:
+$ VV=F$VERIFY(0)
+$ write sys$output P2
+$ 'P2
+$ VV='F$Verify(VV)
+$Exit:
+$ If V Then Set Verify
+$ENDSUBROUTINE
+

png.c

@@ -1,10 +1,10 @@
 
 /* png.c - location for general purpose png functions
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
    */
 
 #define PNG_INTERNAL
@@ -13,7 +13,7 @@
 
 /* version information for c files.  This better match the version
    string defined in png.h */
-char png_libpng_ver[] = "0.87";
+char png_libpng_ver[] = "0.89";
 
 /* place to hold the signiture string for a png file. */
 png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
@@ -25,39 +25,17 @@ png_byte FARDATA png_IHDR[4] = { 73,  72,  68,  82};
 png_byte FARDATA png_IDAT[4] = { 73,  68,  65,  84};
 png_byte FARDATA png_IEND[4] = { 73,  69,  78,  68};
 png_byte FARDATA png_PLTE[4] = { 80,  76,  84,  69};
-#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
 png_byte FARDATA png_gAMA[4] = {103,  65,  77,  65};
-#endif
-#if defined(PNG_READ_sBIT_SUPPORTED) || defined(PNG_WRITE_sBIT_SUPPORTED)
 png_byte FARDATA png_sBIT[4] = {115,  66,  73,  84};
-#endif
-#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
 png_byte FARDATA png_cHRM[4] = { 99,  72,  82,  77};
-#endif
-#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED)
 png_byte FARDATA png_tRNS[4] = {116,  82,  78,  83};
-#endif
-#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED)
 png_byte FARDATA png_bKGD[4] = { 98,  75,  71,  68};
-#endif
-#if defined(PNG_READ_hIST_SUPPORTED) || defined(PNG_WRITE_hIST_SUPPORTED)
 png_byte FARDATA png_hIST[4] = {104,  73,  83,  84};
-#endif
-#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED)
 png_byte FARDATA png_tEXt[4] = {116,  69,  88, 116};
-#endif
-#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
 png_byte FARDATA png_zTXt[4] = {122,  84,  88, 116};
-#endif
-#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
 png_byte FARDATA png_pHYs[4] = {112,  72,  89, 115};
-#endif
-#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
 png_byte FARDATA png_oFFs[4] = {111,  70,  70, 115};
-#endif
-#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
 png_byte FARDATA png_tIME[4] = {116,  73,  77,  69};
-#endif
 
 /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
@@ -95,7 +73,7 @@ int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
 int
 png_check_sig(png_bytep sig, int num)
 {
-	if (num > 8)
+   if (num > 8)
       num = 8;
    if (num < 1)
       return 0;
@@ -107,22 +85,22 @@ png_check_sig(png_bytep sig, int num)
 voidpf
 png_zalloc(voidpf png_ptr, uInt items, uInt size)
 {
-	png_voidp ptr;
-	png_uint_32 num_bytes;
+   png_voidp ptr;
+   png_uint_32 num_bytes;
 
-	ptr = png_large_malloc((png_structp)png_ptr,
-		(png_uint_32)items * (png_uint_32)size);
-	num_bytes = (png_uint_32)items * (png_uint_32)size;
-	if (num_bytes > (png_uint_32)0x7fff)
-	{
-		png_memset(ptr, 0, (png_size_t)0x8000L);
-		png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
-			(png_size_t)(num_bytes - (png_uint_32)0x8000L));
-	}
-	else
-	{
-		png_memset(ptr, 0, (png_size_t)num_bytes);
-	}
+   ptr = png_large_malloc((png_structp)png_ptr,
+      (png_uint_32)items * (png_uint_32)size);
+   num_bytes = (png_uint_32)items * (png_uint_32)size;
+   if (num_bytes > (png_uint_32)0x7fff)
+   {
+      png_memset(ptr, 0, (png_size_t)0x8000L);
+      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
+         (png_size_t)(num_bytes - (png_uint_32)0x8000L));
+   }
+   else
+   {
+      png_memset(ptr, 0, (png_size_t)num_bytes);
+   }
    return (voidpf)(ptr);
 }
 
@@ -130,7 +108,7 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
 void
 png_zfree(voidpf png_ptr, voidpf ptr)
 {
-	png_large_free((png_structp)png_ptr, (png_voidp)ptr);
+   png_large_free((png_structp)png_ptr, (png_voidp)ptr);
 }
 
 /* reset the crc variable to 32 bits of 1's.  Care must be taken
@@ -143,8 +121,8 @@ png_reset_crc(png_structp png_ptr)
 }
 
 /* Note: the crc code below was copied from the sample code in the
-	PNG spec, with appropriate modifications made to ensure the
-	variables are large enough */
+   PNG spec, with appropriate modifications made to ensure the
+   variables are large enough */
 
 /* table of crc's of all 8-bit messages.  If you wish to png_malloc this
    table, turn this into a pointer, and png_malloc it in make_crc_table().
@@ -193,7 +171,7 @@ update_crc(png_uint_32 crc, png_bytep buf, png_uint_32 len)
 
   if (n > 0) do
   {
-	c = crc_table[(png_byte)((c ^ (*p++)) & 0xff)] ^ (c >> 8);
+   c = crc_table[(png_byte)((c ^ (*p++)) & 0xff)] ^ (c >> 8);
   } while (--n);
 
   return c;
@@ -209,10 +187,42 @@ png_calculate_crc(png_structp png_ptr, png_bytep ptr,
 {
    png_ptr->crc = update_crc(png_ptr->crc, ptr, length);
 }
+
+png_infop
+png_create_info_struct(png_structp png_ptr)
+{
+   png_infop info_ptr;
+
+   if ((info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO)) != NULL)
+   {
+      png_memset(info_ptr, 0, sizeof(png_info));
+      png_ptr->do_free |= PNG_FREE_INFO;
+   }
+
+   return info_ptr;
+}
+
 void
 png_info_init(png_infop info)
 {
    /* set everything to 0 */
-	png_memset(info, 0, sizeof (png_info));
+   png_memset(info, 0, sizeof (png_info));
 }
 
+/* This function returns a pointer to the io_ptr associated with the user
+   functions.  The application should free any memory associated with this
+   pointer before png_write_destroy and png_read_destroy are called. */
+png_voidp
+png_get_io_ptr(png_structp png_ptr)
+{
+   return png_ptr->io_ptr;
+}
+ 
+/* Initialize the default input/output functions for the png file.  If you
+   change the read, or write routines, you can call either png_set_read_fn()
+   or png_set_write_fn() instead of png_init_io(). */
+void
+png_init_io(png_structp png_ptr, FILE *fp)
+{
+   png_ptr->io_ptr = (png_voidp)fp;
+}

png.h

@@ -1,19 +1,20 @@
 
 /* png.h - header file for png reference library
 
-   libpng 1.0 beta 2 - version 0.87
-   Jan 15, 1996
+   libpng 1.0 beta 3 - version 0.89
+   May 25, 1996
 
    Note: This is a beta version.  It reads and writes valid files
-   on the platforms I have, but it has had limited portability
-   testing.  Furthermore, 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.
-   Read the readme.txt for more information, and how to contact
-   me if you have any problems, or if you want your compiler/
-   platform to be supported in the next official libpng release.
+   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 the libpng.txt
+   for more information, and how to contact me if you have any
+   problems, or if you want your compiler/platform to be supported
+   in the next official libpng release.
 
-   See readme.txt for more information
+   See libpng.txt for more information
 
    Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
    Contributing Authors:
@@ -27,14 +28,15 @@
    with testing, bug fixes, and patience.  You know who you are.  This
    wouldn't have been possible without all of you.
 
-   Thanks to Frank J. T. Wojcik for reviewing the documentation
+   Thanks to Frank J. T. Wojcik for helping with the documentation
 
    The PNG Reference Library is supplied "AS IS". The Contributing Authors
    and Group 42, Inc. disclaim all warranties, expressed or implied,
    including, without limitation, the warranties of merchantability and of
    fitness for any purpose. The Contributing Authors and Group 42, Inc.
-   assume no liability for damages, direct or consequential, which may
-   result from the use of the PNG Reference Library.
+   assume no liability for direct, indirect, incidental, special, exemplary,
+   or consequential damages, which may result from the use of the PNG
+   Reference Library, even if advised of the possibility of such damage.
 
    Permission is hereby granted to use, copy, modify, and distribute this
    source code, or portions hereof, for any purpose, without fee, subject
@@ -74,10 +76,10 @@
 
 /* version information for png.h - this should match the version
    number in png.c */
-#define PNG_LIBPNG_VER_STRING "0.87"
-/* careful here.  I wanted to use 087, but that would be octal.  Version
+#define PNG_LIBPNG_VER_STRING "0.89"
+/* careful here.  I wanted to use 089, but that would be octal.  Version
    1.0 will be 100 here, etc. */
-#define PNG_LIBPNG_VER 87
+#define PNG_LIBPNG_VER 89
 
 /* variables defined in png.c - only it needs to define PNG_NO_EXTERN */
 #ifndef PNG_NO_EXTERN
@@ -88,18 +90,14 @@ extern char png_libpng_ver[];
 
 /* three color definitions.  The order of the red, green, and blue, (and the
    exact size) is not important, although the size of the fields need to
-   be png_byte or png_uint_16 (as defined below).  While png_color_8 and
-   png_color_16 have more fields then they need, they are never used in
-   arrays, so the size isn't that important.  I thought about using
-   unions, but it looked too clumsy, so I left it. If you're using C++,
-   you can union red, index, and gray, if you really want too. */
+   be png_byte or png_uint_16 (as defined below).  */
 typedef struct png_color_struct
 {
    png_byte red;
    png_byte green;
    png_byte blue;
 } png_color;
-typedef png_color       FAR *      png_colorp;
+typedef png_color       FAR *    png_colorp;
 typedef png_color       FAR * FAR * png_colorpp;
 
 typedef struct png_color_16_struct
@@ -110,7 +108,7 @@ typedef struct png_color_16_struct
    png_uint_16 blue;
    png_uint_16 gray; /* for use in grayscale files */
 } png_color_16;
-typedef png_color_16    FAR *      png_color_16p;
+typedef png_color_16    FAR *    png_color_16p;
 typedef png_color_16    FAR * FAR * png_color_16pp;
 
 typedef struct png_color_8_struct
@@ -121,7 +119,7 @@ typedef struct png_color_8_struct
    png_byte gray; /* for use in grayscale files */
    png_byte alpha; /* for alpha channel files */
 } png_color_8;
-typedef png_color_8     FAR *      png_color_8p;
+typedef png_color_8     FAR *    png_color_8p;
 typedef png_color_8     FAR * FAR * png_color_8pp;
 
 /* png_text holds the text in a png file, and whether they are compressed
@@ -133,7 +131,7 @@ typedef struct png_text_struct
    png_charp text; /* comment */
    png_uint_32 text_length; /* length of text field */
 } png_text;
-typedef png_text        FAR *      png_textp;
+typedef png_text        FAR *    png_textp;
 typedef png_text        FAR * FAR * png_textpp;
 
 /* png_time is a way to hold the time in an machine independent way.
@@ -144,13 +142,12 @@ typedef struct png_time_struct
 {
    png_uint_16 year; /* full year, as in, 1995 */
    png_byte month; /* month of year, 1 - 12 */
-
    png_byte day; /* day of month, 1 - 31 */
    png_byte hour; /* hour of day, 0 - 23 */
    png_byte minute; /* minute of hour, 0 - 59 */
    png_byte second; /* second of minute, 0 - 60 (for leap seconds) */
 } png_time;
-typedef png_time        FAR *      png_timep;
+typedef png_time        FAR *    png_timep;
 typedef png_time        FAR * FAR * png_timepp;
 
 /* png_info is a structure that holds the information in a png file.
@@ -165,18 +162,22 @@ typedef struct png_info_struct
    /* the following are necessary for every png file */
    png_uint_32 width; /* with of file */
    png_uint_32 height; /* height of file */
+   png_uint_32 valid; /* the PNG_INFO_ defines, OR'd together */
+   png_uint_32 rowbytes; /* bytes needed for untransformed row */
+   png_colorp palette; /* palette of file */
+   png_uint_16 num_palette; /* number of values in palette */
+   png_uint_16 num_trans; /* number of trans values */
    png_byte bit_depth; /* 1, 2, 4, 8, or 16 */
    png_byte color_type; /* use the PNG_COLOR_TYPE_ defines */
    png_byte compression_type; /* must be 0 */
    png_byte filter_type; /* must be 0 */
    png_byte interlace_type; /* 0 for non-interlaced, 1 for interlaced */
-   png_uint_32 valid; /* the PNG_INFO_ defines, OR'd together */
    /* the following is informational only on read, and not used on
       writes */
    png_byte channels; /* number of channels of data per pixel */
    png_byte pixel_depth; /* number of bits per pixel */
+   png_byte spare_byte;  /* To align the data, and for future use */
 
-   png_uint_32 rowbytes; /* bytes needed for untransformed row */
    /* the rest are optional.  If you are reading, check the valid
       field to see if the information in these are valid.  If you
       are writing, set the valid field to those chunks you want
@@ -184,9 +185,38 @@ typedef struct png_info_struct
 #if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
    float gamma; /* gamma value of file, if gAMA chunk is valid */
 #endif
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
+    defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
+   int num_text; /* number of comments */
+   int max_text; /* size of text array */
+   png_textp text; /* array of comments */
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
+   png_time mod_time; /* modification time */
+#endif
 #if defined(PNG_READ_sBIT_SUPPORTED) || defined(PNG_WRITE_sBIT_SUPPORTED)
    png_color_8 sig_bit; /* significant bits */
 #endif
+#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED)
+   png_bytep trans; /* tRNS values for palette image */
+   png_color_16 trans_values; /* tRNS values for non-palette image */
+#endif
+#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED)
+   png_color_16 background; /* background color of image */
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
+   png_uint_32 x_offset; /* x offset on page */
+   png_uint_32 y_offset; /* y offset on page */
+   png_byte offset_unit_type; /* offset units type */
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
+   png_uint_32 x_pixels_per_unit; /* x resolution */
+   png_uint_32 y_pixels_per_unit; /* y resolution */
+   png_byte phys_unit_type; /* resolution type */
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED) || defined(PNG_WRITE_hIST_SUPPORTED)
+   png_uint_16p hist; /* histogram of palette usage */
+#endif
 #if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
    float x_white; /* cHRM chunk values */
    float y_white;
@@ -196,62 +226,31 @@ typedef struct png_info_struct
    float y_green;
    float x_blue;
    float y_blue;
-#endif
-   png_colorp palette; /* palette of file */
-   png_uint_16 num_palette; /* number of values in palette */
-   png_uint_16 num_trans; /* number of trans values */
-#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED)
-   png_bytep trans; /* tRNS values for palette image */
-   png_color_16 trans_values; /* tRNS values for non-palette image */
-#endif
-#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED)
-
-   png_color_16 background; /* background color of image */
-#endif
-#if defined(PNG_READ_hIST_SUPPORTED) || defined(PNG_WRITE_hIST_SUPPORTED)
-   png_uint_16p hist; /* histogram of palette usage */
-#endif
-#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
-   png_uint_32 x_pixels_per_unit; /* x resolution */
-   png_uint_32 y_pixels_per_unit; /* y resolution */
-   png_byte phys_unit_type; /* resolution type */
-#endif
-#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
-   png_uint_32 x_offset; /* x offset on page */
-   png_uint_32 y_offset; /* y offset on page */
-   png_byte offset_unit_type; /* offset units type */
-#endif
-#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
-   png_time mod_time; /* modification time */
-#endif
-#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
-    defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
-   int num_text; /* number of comments */
-   int max_text; /* size of text array */
-   png_textp text; /* array of comments */
 #endif
 } png_info;
-typedef png_info        FAR *      png_infop;
+typedef png_info        FAR *    png_infop;
 typedef png_info        FAR * FAR * png_infopp;
 
 #define PNG_RESOLUTION_UNKNOWN 0
-#define PNG_RESOLUTION_METER 1
+#define PNG_RESOLUTION_METER   1
+#define PNG_RESOLUTION_LAST    2
 
-#define PNG_OFFSET_PIXEL 0
-#define PNG_OFFSET_MICROMETER 1
+#define PNG_OFFSET_PIXEL       0
+#define PNG_OFFSET_MICROMETER  1
+#define PNG_OFFSET_LAST        2
 
 /* these describe the color_type field in png_info */
 
 /* color type masks */
 #define PNG_COLOR_MASK_PALETTE 1
-#define PNG_COLOR_MASK_COLOR 2
-#define PNG_COLOR_MASK_ALPHA 4
+#define PNG_COLOR_MASK_COLOR   2
+#define PNG_COLOR_MASK_ALPHA   4
 
 /* color types.  Note that not all combinations are legal */
+#define PNG_COLOR_TYPE_GRAY 0
 #define PNG_COLOR_TYPE_PALETTE \
    (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
 #define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
-#define PNG_COLOR_TYPE_GRAY 0
 #define PNG_COLOR_TYPE_RGB_ALPHA \
    (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
 #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
@@ -269,11 +268,6 @@ typedef png_info        FAR * FAR * png_infopp;
 #define PNG_INFO_oFFs 0x0100
 #define PNG_INFO_tIME 0x0200
 
-/* these determine if a function in the info needs to be freed */
-#define PNG_FREE_PALETTE 0x0001
-#define PNG_FREE_HIST 0x0002
-#define PNG_FREE_TRANS 0x0004
-
 /* this is used for the transformation routines, as some of them
    change these values for the row.  It also should enable using
    the routines for other uses. */
@@ -287,18 +281,18 @@ typedef struct png_row_info_struct
    png_byte pixel_depth; /* bits per pixel (depth * channels) */
 } png_row_info;
 
-typedef png_row_info    FAR *      png_row_infop;
+typedef png_row_info    FAR *    png_row_infop;
 typedef png_row_info    FAR * FAR * png_row_infopp;
 
 /* These are the function types for the I/O functions, and the functions which
- * modify the default I/O functions to user I/O functions.  The png_msg_ptr
+ * modify the default I/O functions to user I/O functions.  The png_error_ptr
  * type should match that of user supplied warning and error functions, while
  * the png_rw_ptr type should match that of the user read/write data functions.
  */
 typedef struct png_struct_def png_struct;
 typedef png_struct FAR * png_structp;
 
-typedef void (*png_msg_ptr) PNGARG((png_structp, png_const_charp));
+typedef void (*png_error_ptr) PNGARG((png_structp, png_const_charp));
 typedef void (*png_rw_ptr) PNGARG((png_structp, png_bytep, png_uint_32));
 typedef void (*png_flush_ptr) PNGARG((png_structp));
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
@@ -316,55 +310,28 @@ typedef void (*png_progressive_row_ptr) PNGARG((png_structp, png_bytep,
 struct png_struct_def
 {
    jmp_buf jmpbuf; /* used in png_error */
+
+   png_error_ptr error_fn;    /* Function for printing errors and aborting */
+   png_error_ptr warning_fn;  /* Function for printing warnings */
+   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 */
+   png_voidp io_ptr;  /* Pointer to user supplied struct for I/O functions */
+
    png_byte mode; /* used to determine where we are in the png file */
-   png_byte read_mode;
-   png_byte color_type; /* color type of file */
-   png_byte bit_depth; /* bit depth of file */
-   png_byte interlaced; /* interlace type of file */
-   png_byte compession; /* compression type of file */
-   png_byte filter; /* filter type */
-   png_byte channels; /* number of channels in file */
-   png_byte pixel_depth; /* number of bits per pixel */
-   png_byte usr_bit_depth; /* bit depth of users row */
-   png_byte usr_channels; /* channels at start of write */
-#if defined(PNG_READ_GAMMA_SUPPORTED)
-   png_byte gamma_shift; /* amount of shift for 16 bit gammas */
-#endif
-   png_byte pass; /* current pass (0 - 6) */
-   png_byte row_init; /* 1 if png_read_start_row() has been called */
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_byte background_gamma_type;
-   png_byte background_expand;
-#endif
-   png_byte zlib_finished;
-   png_byte user_palette;
-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
-   png_byte filler;
-   png_byte filler_loc;
-#endif
-   png_byte zlib_custom_level; /* one if custom compression level */
-   png_byte zlib_custom_method; /* one if custom compression method */
-   png_byte zlib_custom_window_bits; /* one if custom compression window bits */
-   png_byte zlib_custom_mem_level; /* one if custom compression memory level */
-   png_byte zlib_custom_strategy; /* one if custom compression strategy */
-   png_byte do_filter; /* one if filtering, zero if not */
-   png_byte do_custom_filter; /* one if filtering, zero if not */
-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
-   png_byte have_chunk_header;
-#endif
-   png_uint_16 num_palette; /* number of entries in palette */
-   png_uint_16 num_trans; /* number of transparency values */
+   png_uint_32 do_free; /* flags indicating if libpng should free memory */
+   png_uint_32 flags;  /* flags indicating various things to libpng */
+   png_uint_32 transformations; /* which transformations to perform */
+
+   z_stream * zstream; /* pointer to decompression structure (below) */
+   png_bytep zbuf; /* buffer for zlib */
+   png_uint_32 zbuf_size; /* size of zbuf */
    int zlib_level; /* holds zlib compression level */
    int zlib_method; /* holds zlib compression method */
    int zlib_window_bits; /* holds zlib compression window bits */
    int zlib_mem_level; /* holds zlib compression memory level */
    int zlib_strategy; /* holds zlib compression strategy */
-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
-   int process_mode;
-   int cur_palette;
-#endif
-   png_uint_32 transformations; /* which transformations to perform */
-   png_uint_32 crc; /* current crc value */
+
    png_uint_32 width; /* width of file */
    png_uint_32 height; /* height of file */
    png_uint_32 num_rows; /* number of rows in current pass */
@@ -373,20 +340,87 @@ struct png_struct_def
    png_uint_32 iwidth; /* interlaced width */
    png_uint_32 irowbytes; /* interlaced rowbytes */
    png_uint_32 row_number; /* current row in pass */
+   png_bytep row_buf; /* row buffer */
+   png_bytep prev_row; /* previous row */
+   png_bytep sub_row;  /* place to save row when filtering */
+   png_bytep up_row;   /* place to save row when filtering */
+   png_bytep avg_row;  /* place to save row when filtering */
+   png_bytep paeth_row; /* place to save row when filtering */
+   png_row_info row_info; /* used for transformation routines */
+
    png_uint_32 idat_size; /* current idat size for read */
-   png_uint_32 zbuf_size; /* size of zbuf */
-   png_uint_32 do_free; /* flags indicating if libpng should free memory */
+   png_uint_32 crc; /* current crc value */
+   png_colorp palette; /* files palette */
+   png_uint_16 num_palette; /* number of entries in palette */
+   png_uint_16 num_trans; /* number of transparency values */
+   png_byte interlaced; /* interlace type of file */
+   png_byte pass; /* current pass (0 - 6) */
+   png_byte compression; /* compression type of file */
+   png_byte filter; /* filter type */
+   png_byte do_filter; /* non-zero if row filtering, zero if not */
+   png_byte color_type; /* color type of file */
+   png_byte bit_depth; /* bit depth of file */
+   png_byte usr_bit_depth; /* bit depth of users row */
+   png_byte pixel_depth; /* number of bits per pixel */
+   png_byte channels; /* number of channels in file */
+   png_byte usr_channels; /* channels at start of write */
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+   png_byte filler; /* filler byte to be used for 32-bit frame buffers */
+#endif
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+   png_byte background_gamma_type;
+   float background_gamma;
+   png_color_16 background; /* background color, gamma corrected for screen */
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+   png_color_16 background_1; /* background normalized to gamma 1.0 */
+#endif
+#endif
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
+   png_flush_ptr output_flush_fn;/* Function for flushing output */
    png_uint_32 flush_dist;  /* how many rows apart to flush, 0 for no flush */
    png_uint_32 flush_rows;  /* number of rows written since last flush */
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
+#if defined(PNG_READ_GAMMA_SUPPORTED)
+   int gamma_shift; /* amount of shift for 16 bit gammas */
+   float gamma; /* file gamma value */
+   float display_gamma; /* display gamma value */
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   png_bytep gamma_table; /* gamma table for 8 bit depth files */
+   png_bytep gamma_from_1; /* converts from 1.0 to screen */
+   png_bytep gamma_to_1; /* converts from file to 1.0 */
+   png_uint_16pp gamma_16_table; /* gamma table for 16 bit depth files */
+   png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
+   png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined (PNG_READ_sBIT_SUPPORTED)
+   png_color_8 sig_bit; /* significant bits in file */
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   png_bytep trans; /* transparency values for paletted files */
+   png_color_16 trans_values; /* transparency values for non-paletted files */
+#endif
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+   png_color_8 shift; /* shift for significant bit tranformation */
+#endif
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+   png_progressive_info_ptr info_fn;
+   png_progressive_row_ptr row_fn;
+   png_progressive_end_ptr end_fn;
+   png_bytep save_buffer_ptr;
+   png_bytep save_buffer;
+   png_bytep current_buffer_ptr;
+   png_bytep current_buffer;
    png_uint_32 push_length;
    png_uint_32 skip_length;
    png_uint_32 save_buffer_size;
    png_uint_32 save_buffer_max;
    png_uint_32 buffer_size;
    png_uint_32 current_buffer_size;
+   int process_mode;
+   int cur_palette;
+   png_byte push_chunk_name[4];
 #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
    png_uint_32 current_text_size;
    png_uint_32 current_text_left;
@@ -401,85 +435,29 @@ struct png_struct_def
    png_uint_16 offset_table_count;
    png_uint_16 offset_table_count_free;
 #endif
-   png_byte push_chunk_name[4];
-   png_bytep save_buffer_ptr;
-   png_bytep save_buffer;
-   png_bytep current_buffer_ptr;
-   png_bytep current_buffer;
-#endif
-   png_colorp palette; /* files palette */
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
 #if defined(PNG_READ_DITHER_SUPPORTED)
    png_bytep palette_lookup; /* lookup table for dithering */
-#endif
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_bytep gamma_table; /* gamma table for 8 bit depth files */
-#endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_bytep gamma_from_1; /* converts from 1.0 to screen */
-   png_bytep gamma_to_1; /* converts from file to 1.0 */
-#endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_bytep trans; /* transparency values for paletted files */
-#endif
-#if defined(PNG_READ_DITHER_SUPPORTED)
    png_bytep dither_index; /* index translation for palette files */
-#endif
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_uint_16pp gamma_16_table; /* gamma table for 16 bit depth files */
-#endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
-   png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
-#endif
-#if defined(PNG_READ_DITHER_SUPPORTED)
    png_uint_16p hist; /* histogram */
 #endif
-   png_bytep zbuf; /* buffer for zlib */
-   png_bytep row_buf; /* row buffer */
-   png_bytep prev_row; /* previous row */
-   png_bytep save_row; /* place to save row before filtering */
-   z_stream * zstream; /* pointer to decompression structure (below) */
-#if defined(PNG_READ_GAMMA_SUPPORTED)
-   float gamma; /* file gamma value */
-   float display_gamma; /* display gamma value */
-#endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-   float background_gamma;
-#endif
-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
-   png_color_8 shift; /* shift for significant bit tranformation */
-#endif
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined (PNG_READ_sBIT_SUPPORTED)
-   png_color_8 sig_bit; /* significant bits in file */
-#endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_color_16 trans_values; /* transparency values for non-paletted files */
-   png_color_16 background; /* background color, gamma corrected for screen */
-#if defined(PNG_READ_GAMMA_SUPPORTED)
-   png_color_16 background_1; /* background normalized to gamma 1.0 */
-#endif
-#endif
-   png_row_info row_info; /* used for transformation routines */
-   FILE *fp; /* used for default png_read and png_write */
-   png_msg_ptr error_fn;         /* Function for printing errors and aborting */
-   png_msg_ptr warning_fn;       /* Function for printing warnings */
-   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_WRITE_FLUSH_SUPPORTED)
-   png_flush_ptr output_flush_fn;/* Function for flushing output */
-#endif /* PNG_WRITE_FLUSH_SUPPORTED */
-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
-   png_progressive_info_ptr info_fn;
-   png_progressive_row_ptr row_fn;
-   png_progressive_end_ptr end_fn;
-   png_voidp push_ptr;
-#endif
-   png_voidp io_ptr;  /* Pointer to user supplied struct for I/O functions */
-   png_voidp msg_ptr;  /* Pointer to user supplied struct for message functions */
 };
 
 typedef png_struct      FAR * FAR * png_structpp;
 
+/* flags for png_set_filter() to say which filters to use.  The flags
+   are chosen so that they don't conflict with real filter types, in case they
+   are supplied instead of the #defined constants.
+ */
+#define PNG_NO_FILTERS     0x00
+#define PNG_FILTER_NONE    0x08
+#define PNG_FILTER_SUB     0x10
+#define PNG_FILTER_UP      0x20
+#define PNG_FILTER_AVG     0x40
+#define PNG_FILTER_PAETH   0x80
+#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \
+                         PNG_FILTER_AVG | PNG_FILTER_PAETH)
+
 /* Here are the function definitions most commonly used.  This is not
    the place to find out how to use libpng.  See libpng.txt for the
    full explanation, see example.c for the summary.  This just provides
@@ -488,13 +466,31 @@ typedef png_struct      FAR * FAR * png_structpp;
 /* check the first 1 - 8 bytes to see if it is a png file */
 extern int png_check_sig PNGARG((png_bytep sig, int num));
 
-/* initialize png structure for reading, and allocate any memory needed */
+/* allocate and initialize png structure for reading, and any other memory */
+extern png_structp png_create_read_struct PNGARG((png_const_charp user_png_ver,
+   voidp error_ptr, png_error_ptr warn_fn, png_error_ptr error_fn));
+ 
+/* reset the png_struct to read a new image */
+extern void png_reset_read_struct PNGARG((png_structpp png_ptr));
+
+/* initialize png structure for reading, and allocate any other memory (old) */
 extern void png_read_init PNGARG((png_structp png_ptr));
 
-/* initialize png structure for writing, and allocate any memory needed */
+/* allocate and initialize png structure for reading, and any other memory */
+extern png_structp png_create_write_struct
+   PNGARG((png_const_charp user_png_ver, voidp error_ptr,
+   png_error_ptr warn_fn, png_error_ptr error_fn));
+
+/* reset the png_struct to read a new image */
+extern void png_reset_write_struct PNGARG((png_structpp png_ptr));
+
+/* initialize png structure for writing, and allocate any other memory (old) */
 extern void png_write_init PNGARG((png_structp png_ptr));
 
-/* initialize the info structure */
+/* allocate and initialize the info structure */
+extern png_infop png_create_info_struct PNGARG((png_structp png_ptr));
+
+/* initialize the info structure (old interface) */
 extern void png_info_init PNGARG((png_infop info));
 
 /* Writes all the png information before the image. */
@@ -506,7 +502,7 @@ extern void png_read_info PNGARG((png_structp png_ptr, png_infop info));
 #if defined(PNG_WRITE_tIME_SUPPORTED)
 /* convert from a struct tm to png_time */
 extern void png_convert_from_struct_tm PNGARG((png_timep ptime,
-   struct tm FAR * ttime)); /*SJT: struct tm FAR *tttime ??? */
+   struct tm FAR * ttime));
 
 /* convert from time_t to png_time.  Uses gmtime() */
 extern void png_convert_from_time_t PNGARG((png_timep ptime, time_t ttime));
@@ -533,7 +529,7 @@ extern void png_set_gray_to_rgb PNGARG((png_structp png_ptr));
 #define PNG_FILLER_AFTER 1
 /* Add a filler byte to rgb images. */
 extern void png_set_filler PNGARG((png_structp png_ptr, int filler,
-   int filler_loc));
+   int flags));
 
 /* old ways of doing this, still supported through 1.x for backwards
    compatability, but not suggested */
@@ -574,10 +570,10 @@ extern void png_set_invert_mono PNGARG((png_structp png_ptr));
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
 /* Handle alpha and tRNS by replacing with a background color. */
-#define PNG_BACKGROUND_GAMMA_SCREEN 0
-#define PNG_BACKGROUND_GAMMA_FILE 1
-#define PNG_BACKGROUND_GAMMA_UNIQUE 2
-#define PNG_BACKGROUND_GAMMA_UNKNOWN 3
+#define PNG_BACKGROUND_GAMMA_UNKNOWN 0
+#define PNG_BACKGROUND_GAMMA_SCREEN  1
+#define PNG_BACKGROUND_GAMMA_FILE    2
+#define PNG_BACKGROUND_GAMMA_UNIQUE  3
 extern void png_set_background PNGARG((png_structp png_ptr,
    png_color_16p background_color, int background_gamma_code,
    int need_expand, double background_gamma));
@@ -653,10 +649,22 @@ extern void png_write_end PNGARG((png_structp png_ptr, png_infop info));
 /* read the end of the png file. */
 extern void png_read_end PNGARG((png_structp png_ptr, png_infop info));
 
-/* free all memory used by the read */
+/* free the info structure */
+extern void png_destroy_info_struct PNGARG((png_structp png_ptr,
+   png_infopp info_ptr));
+
+/* free any memory associated with the png_struct and the info_structs */
+extern void png_destroy_read_struct PNGARG((png_structpp png_ptr,
+   png_infopp info, png_infopp end_info));
+
+/* free all memory used by the read (old method) */
 extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info,
    png_infop end_info));
 
+/* free any memory associated with the png_struct and the info_structs */
+extern void png_destroy_write_struct PNGARG((png_structpp png_ptr,
+   png_infopp info));
+
 /* free any memory used in png struct */
 extern void png_write_destroy PNGARG((png_structp png_ptr));
 
@@ -667,7 +675,8 @@ extern void png_write_destroy PNGARG((png_structp png_ptr));
    performance at the expense of compression can modify them.
    See the compression library header file for an explination
    of these functions */
-extern void png_set_filtering PNGARG((png_structp png_ptr, int filter));
+extern void png_set_filter PNGARG((png_structp png_ptr, int method,
+   int filters));
 
 extern void png_set_compression_level PNGARG((png_structp png_ptr,
    int level));
@@ -684,10 +693,12 @@ extern void png_set_compression_window_bits PNGARG((png_structp png_ptr,
 extern void png_set_compression_method PNGARG((png_structp png_ptr,
    int method));
 
-/* These next functions are stubs of typical c functions for input/output,
-   memory, and error handling.  They are in the file pngio.c, and pngerror.c.
-   These functions can be replaced at run time for those applications that
-   need to handle I/O in a different manner.  See the file libpng.txt for
+/* These next functions are called for input/output, memory, and error
+   handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,
+   and call standard C I/O routines such as fread(), fwrite(), and
+   fprintf().  These functions can be made to use other I/O routines
+   at run time for those applications that need to handle I/O in a
+   different manner by calling png_set_???_fn().  See libpng.txt for
    more information */
 
 /* Write the data to whatever output you are using. */
@@ -707,11 +718,11 @@ extern void png_init_io PNGARG((png_structp png_ptr, FILE *fp));
    still do a longjmp to the last setjmp location if you are using this
    method of error handling.  If error_fn or warning_fn is NULL, the
    default functions will be used. */
-extern void png_set_message_fn PNGARG((png_structp png_ptr, png_voidp msg_ptr,
-   png_msg_ptr error_fn, png_msg_ptr warning_fn));
+extern void png_set_error_fn PNGARG((png_structp png_ptr, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warning_fn));
 
-/* Return the user pointer associated with the message functions */
-extern png_voidp png_get_msg_ptr PNGARG((png_structp png_ptr));
+/* Return the user pointer associated with the error functions */
+extern png_voidp png_get_error_ptr PNGARG((png_structp png_ptr));
 
 /* Replace the default data output functions with a user supplied one(s).
    If buffered output is not used, then output_flush_fn can be set to NULL.
@@ -753,6 +764,12 @@ extern void * png_realloc PNGARG((png_structp png_ptr, void * ptr,
 /* free's a pointer allocated by png_malloc() */
 extern void png_free PNGARG((png_structp png_ptr, void * ptr));
 
+/* allocate memory for an internal libpng struct */
+extern png_voidp png_create_struct PNGARG((uInt type));
+
+/* free memory from internal libpng struct */
+extern void png_destroy_struct PNGARG((voidp struct_ptr));
+
 /* Fatal error in libpng - can't continue */ 
 extern void png_error PNGARG((png_structp png_ptr, png_const_charp error));
 
@@ -767,50 +784,74 @@ extern void png_warning PNGARG((png_structp png_ptr, png_const_charp message));
    define PNG_INTERNAL inside your code, so everyone who includes png.h
    won't get yet another definition the compiler has to deal with. */
 
-#ifdef PNG_INTERNAL
+#if defined(PNG_INTERNAL)
 
 /* various modes of operation.  Note that after an init, mode is set to
    zero automatically */
-#define PNG_BEFORE_IHDR 0
-#define PNG_HAVE_IHDR 1
-#define PNG_HAVE_PLTE 2
-#define PNG_HAVE_IDAT 3
-#define PNG_AT_LAST_IDAT 4
-#define PNG_AFTER_IDAT 5
-#define PNG_AFTER_IEND 6
+#define PNG_BEFORE_IHDR  0x00
+#define PNG_HAVE_IHDR    0x01
+#define PNG_HAVE_PLTE    0x02
+#define PNG_HAVE_IDAT    0x04
+#define PNG_AT_LAST_IDAT 0x08
+#define PNG_AFTER_IDAT   0x10
+#define PNG_AFTER_IEND   0x20
 
 /* push model modes */
-#define PNG_READ_SIG_MODE 0
+#define PNG_READ_SIG_MODE   0
 #define PNG_READ_CHUNK_MODE 1
-#define PNG_READ_IDAT_MODE 2
-#define PNG_READ_PLTE_MODE 3
-#define PNG_READ_END_MODE 4
-#define PNG_SKIP_MODE 5
-#define PNG_READ_tEXt_MODE 6
-#define PNG_READ_zTXt_MODE 7
-#define PNG_READ_DONE_MODE 8
-#define PNG_ERROR_MODE 9
+#define PNG_READ_IDAT_MODE  2
+#define PNG_READ_PLTE_MODE  3
+#define PNG_READ_END_MODE   4
+#define PNG_SKIP_MODE       5
+#define PNG_READ_tEXt_MODE  6
+#define PNG_READ_zTXt_MODE  7
+#define PNG_READ_DONE_MODE  8
+#define PNG_ERROR_MODE      9
 
 /* read modes */
 #define PNG_READ_PULL_MODE 0
 #define PNG_READ_PUSH_MODE 1
 
 /* defines for the transformations the png library does on the image data */
-#define PNG_BGR 0x0001
-#define PNG_INTERLACE 0x0002
-#define PNG_PACK 0x0004
-#define PNG_SHIFT 0x0008
-#define PNG_SWAP_BYTES 0x0010
-#define PNG_INVERT_MONO 0x0020
-#define PNG_DITHER 0x0040
-#define PNG_BACKGROUND 0x0080
-#define PNG_XRGB 0x0100
-#define PNG_16_TO_8 0x0200
-#define PNG_RGBA 0x0400
-#define PNG_EXPAND 0x0800
-#define PNG_GAMMA 0x1000
-#define PNG_GRAY_TO_RGB 0x2000
-#define PNG_FILLER 0x4000
+#define PNG_BGR                0x0001
+#define PNG_INTERLACE          0x0002
+#define PNG_PACK               0x0004
+#define PNG_SHIFT              0x0008
+#define PNG_SWAP_BYTES         0x0010
+#define PNG_INVERT_MONO        0x0020
+#define PNG_DITHER             0x0040
+#define PNG_BACKGROUND         0x0080
+#define PNG_BACKGROUND_EXPAND  0x0100
+#define PNG_XRGB               0x0200
+#define PNG_16_TO_8            0x0400
+#define PNG_RGBA               0x0800
+#define PNG_EXPAND             0x1000
+#define PNG_GAMMA              0x2000
+#define PNG_GRAY_TO_RGB        0x4000
+#define PNG_FILLER             0x8000
+
+/* flags for png_ptr->do_free to say if memory in png_info needs to be freed */
+#define PNG_FREE_PALETTE 0x0001
+#define PNG_FREE_HIST    0x0002
+#define PNG_FREE_TRANS   0x0004
+#define PNG_FREE_STRUCT  0x0008
+#define PNG_FREE_INFO    0x0010
+
+/* flags for png_create_struct */
+#define PNG_STRUCT_PNG   0x0001
+#define PNG_STRUCT_INFO  0x0002
+
+/* flags for the png_ptr->flags rather than declaring a bye for each one */
+#define PNG_FLAG_WROTE_tIME               0x0001
+#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0002
+#define PNG_FLAG_ZLIB_CUSTOM_LEVEL        0x0004
+#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL    0x0008
+#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS  0x0010
+#define PNG_FLAG_ZLIB_CUSTOM_METHOD       0x0020
+#define PNG_FLAG_ZLIB_FINISHED            0x0040
+#define PNG_FLAG_ROW_INIT                 0x0080
+#define PNG_FLAG_FILLER_AFTER             0x0100
+#define PNG_FLAG_HAVE_CHUNK_HEADER        0x0200
 
 /* save typing and make code easier to understand */
 #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
@@ -826,44 +867,24 @@ extern png_byte png_sig[];
 extern char png_libpng_ver[];
 
 /* constant strings for known chunk types.  If you need to add a chunk,
-   add a string holding the name here.  See png.c for more details */
+   add a string holding the name here.  See png.c for more details.  We
+   can't selectively include these, since we still check for chunk in the
+   wrong locations with these labels. */
 extern png_byte FARDATA png_IHDR[];
 extern png_byte FARDATA png_IDAT[];
 extern png_byte FARDATA png_IEND[];
 extern png_byte FARDATA png_PLTE[];
-#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
 extern png_byte FARDATA png_gAMA[];
-#endif
-#if defined(PNG_READ_sBIT_SUPPORTED) || defined(PNG_WRITE_sBIT_SUPPORTED)
 extern png_byte FARDATA png_sBIT[];
-#endif
-#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
 extern png_byte FARDATA png_cHRM[];
-#endif
-#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED)
 extern png_byte FARDATA png_tRNS[];
-#endif
-#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED)
 extern png_byte FARDATA png_bKGD[];
-#endif
-#if defined(PNG_READ_hIST_SUPPORTED) || defined(PNG_WRITE_hIST_SUPPORTED)
 extern png_byte FARDATA png_hIST[];
-#endif
-#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED)
 extern png_byte FARDATA png_tEXt[];
-#endif
-#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
 extern png_byte FARDATA png_zTXt[];
-#endif
-#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED)
 extern png_byte FARDATA png_pHYs[];
-#endif
-#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)
 extern png_byte FARDATA png_oFFs[];
-#endif
-#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
 extern png_byte FARDATA png_tIME[];
-#endif
 /* Structures to facilitate easy interlacing.  See png.c for more details */
 extern int FARDATA png_pass_start[];
 extern int FARDATA png_pass_inc[];
@@ -894,14 +915,8 @@ extern void png_reset_crc PNGARG((png_structp png_ptr));
 extern void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,
    png_uint_32 length));
 
-/* default error and warning functions if user doesn't supply them */
-extern void png_default_warning PNGARG((png_structp png_ptr,
-   png_const_charp message));
-extern void png_default_error PNGARG((png_structp png_ptr,
-   png_const_charp error));
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
 extern void png_flush PNGARG((png_structp png_ptr));
-extern void png_default_flush PNGARG((png_structp png_ptr));
 #endif
 
 /* place a 32 bit number into a buffer in png byte order.  We work
@@ -1105,11 +1120,14 @@ extern void png_do_write_interlace PNGARG((png_row_infop row_info,
 #endif
 
 /* unfilter a row */
-extern void png_read_filter_row PNGARG((png_row_infop row_info,
-   png_bytep row, png_bytep prev_row, int filter));
-/* filter a row, and place the correct filter byte in the row */
-extern void png_write_filter_row PNGARG((png_row_infop row_info,
-   png_bytep row, png_bytep prev_row));
+extern void png_read_filter_row PNGARG((png_structp png_ptr,
+   png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));
+/* choose the best filter to use and filter the row data */
+extern void png_write_find_filter PNGARG((png_structp png_ptr,
+   png_row_infop row_info));
+/* write out the filtered row */
+extern void png_write_filtered_row PNGARG((png_structp png_ptr,
+   png_bytep filtered_row));
 /* finish a row while reading, dealing with interlacing passes, etc. */
 extern void png_read_finish_row PNGARG((png_structp png_ptr));
 /* initialize the row buffers, etc. */
@@ -1163,6 +1181,11 @@ extern void png_do_dither PNGARG((png_row_infop row_info,
    png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));
 #endif
 
+#if defined(PNG_CORRECT_PALETTE_SUPPORTED)
+extern void png_correct_palette PNGARG((png_structp png_ptr,
+   png_colorp palette, int num_palette));
+#endif
+
 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
 extern void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));
 #endif
@@ -1289,13 +1312,13 @@ extern void png_push_fill_buffer PNGARG((png_structp png_ptr, png_bytep buffer,
 extern void png_push_save_buffer PNGARG((png_structp png_ptr));
 extern void png_push_restore_buffer PNGARG((png_structp png_ptr, png_bytep buffer,
    png_uint_32 buffer_length));
-extern void png_push_read_idat PNGARG((png_structp png_ptr));
+extern void png_push_read_IDAT PNGARG((png_structp png_ptr));
 extern void png_process_IDAT_data PNGARG((png_structp png_ptr,
    png_bytep buffer, png_uint_32 buffer_length));
 extern void png_push_process_row PNGARG((png_structp png_ptr));
 extern void png_push_handle_PLTE PNGARG((png_structp png_ptr,
    png_uint_32 length));
-extern void png_push_read_plte PNGARG((png_structp png_ptr, png_infop info));
+extern void png_push_read_PLTE PNGARG((png_structp png_ptr, png_infop info));
 extern void png_push_handle_tRNS PNGARG((png_structp png_ptr, png_infop info,
    png_uint_32 length));
 extern void png_push_handle_hIST PNGARG((png_structp png_ptr, png_infop info,
@@ -1310,12 +1333,12 @@ extern void png_read_push_finish_row PNGARG((png_structp png_ptr));
 #if defined(PNG_READ_tEXt_SUPPORTED)
 extern void png_push_handle_tEXt PNGARG((png_structp png_ptr,
    png_uint_32 length));
-extern void png_push_read_text PNGARG((png_structp png_ptr, png_infop info));
+extern void png_push_read_tEXt PNGARG((png_structp png_ptr, png_infop info));
 #endif
 #if defined(PNG_READ_zTXt_SUPPORTED)
 extern void png_push_handle_zTXt PNGARG((png_structp png_ptr,
    png_uint_32 length));
-extern void png_push_read_ztxt PNGARG((png_structp png_ptr, png_infop info));
+extern void png_push_read_zTXt PNGARG((png_structp png_ptr, png_infop info));
 #endif
 
 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

pngchang.txt

@@ -1,31 +1,31 @@
 pngchange.txt - changes for libpng
 
 version 0.2
-	added reader into png.h
-	fixed small problems in stub file
+   added reader into png.h
+   fixed small problems in stub file
 version 0.3
-	added pull reader
-	split up pngwrite.c to several files
-	added pnglib.txt
-	added example.c
-	cleaned up writer, adding a few new tranformations
-	fixed some bugs in writer
-	interfaced with zlib 0.5
-	added K&R support
-	added check for 64 KB blocks for 16 bit machines
+   added pull reader
+   split up pngwrite.c to several files
+   added pnglib.txt
+   added example.c
+   cleaned up writer, adding a few new tranformations
+   fixed some bugs in writer
+   interfaced with zlib 0.5
+   added K&R support
+   added check for 64 KB blocks for 16 bit machines
 version 0.4
-	cleaned up code and commented code
-	simplified time handling into png_time
-	created png_color_16 and png_color_8 to handle color needs
-	cleaned up color type defines
-	fixed various bugs
-	made various names more consistant
-	interfaced with zlib 0.71
-	cleaned up zTXt reader and writer (using zlib's Reset functions)
-	split transformations into pngrtran.c and pngwtran.c
+   cleaned up code and commented code
+   simplified time handling into png_time
+   created png_color_16 and png_color_8 to handle color needs
+   cleaned up color type defines
+   fixed various bugs
+   made various names more consistant
+   interfaced with zlib 0.71
+   cleaned up zTXt reader and writer (using zlib's Reset functions)
+   split transformations into pngrtran.c and pngwtran.c
 version 0.5
-	interfaced with zlib 0.8
-	fixed many reading and writing bugs
+   interfaced with zlib 0.8
+   fixed many reading and writing bugs
    saved using 3 spaces instead of tabs
 version 0.6
    added png_large_malloc() and png_large_free()
@@ -54,7 +54,8 @@ version 0.8
    changed external functions passing floats to doubles (k&r problems?)
    put all the configurable stuff in pngconf.h
    enabled png_set_shift to work with paletted images on read
-   added png_read_update_info() - updates info structure with transformations
+   added png_read_update_info() - updates info structure with
+      transformations
 version 0.81
    incorporated Tim Wegner's medium model code (thanks, Tim)
 version 0.85
@@ -66,7 +67,37 @@ version 0.86
    fixed bugs
    improved documentation
 version 0.87
-	fixed medium model bugs
-	fixed other bugs introduced in 0.85 and 0.86
+   fixed medium model bugs
+   fixed other bugs introduced in 0.85 and 0.86
    added some minor documentation
-
+version 0.88
+   fixed progressive bugs
+   replaced tabs with spaces
+   cleaned up documentation
+   added callbacks for read/write and warning/error functions
+version 0.89 
+   added new initialization API to make libpng work better with shared libs
+      we now have png_create_read_struct(), png_create_write_struct(),
+      png_create_info_struct(), png_destroy_read_struct(), and
+      png_destroy_write_struct() instead of the separate calls to
+      malloc and png_read_init(), png_info_init(), and png_write_init()
+   changed warning/error callback functions to fix bug - this means you
+      should use the new initialization API if you were using the old
+      png_set_message_fn() calls, and that the old API no longer exists
+      so that people are aware that they need to change their code
+   changed filter selection API to allow selection of multiple filters
+      since it didn't work in previous versions of libpng anyways
+   optimized filter selection code    
+   fixed png_set_background() to allow using an arbitrary RGB color for
+      paletted images
+   fixed gamma and background correction for paletted images, so
+      png_correct_palette is not needed unless you are correcting an
+      external palette (you will need to #define PNG_CORRECT_PALETTE_SUPPORTED
+      in pngconf.h)
+   fixed bug with Borland 64K memory allocation (Alexander Lehmann)
+   fixed bug in interlace handling (Smaraderagd, I think)
+   added more error checking for writing and image to reduce invalid files
+   separated read and write functions so that they won't both be linked
+      into a binary when only reading or writing functionality is used
+   new pngtest image also has interlacing and zTXt
+   updated dcumentation to reflect new API

pngconf.h

@@ -1,10 +1,10 @@
 
 /* pngconf.c - machine configurable file for libpng
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
    */
 
 /* Any machine specific code is near the front of this file, so if you
@@ -27,7 +27,7 @@
    Unless this gets smaller then the size of a row (compressed),
    it should not make much difference how big this is.  */
 
-#define PNG_ZBUF_SIZE 32768
+#define PNG_ZBUF_SIZE 8192
 
 /* While libpng currently uses zlib for it's compression, it has been designed
    to stand on it's own.  Towards this end, there are two defines that are
@@ -49,10 +49,10 @@
 #endif
 
 /* this protects us against compilers which run on a windowing system
-	and thus don't have or would rather us not use the stdio types:
-	stdin, stdout, and stderr.  The only one currently used is stderr
-	in png_error() and png_warning().  #defining PNG_NO_STDIO will
-	prevent these from being compiled and used. */
+   and thus don't have or would rather us not use the stdio types:
+   stdin, stdout, and stderr.  The only one currently used is stderr
+   in png_error() and png_warning().  #defining PNG_NO_STDIO will
+   prevent these from being compiled and used. */
 
 /* #define PNG_NO_STDIO */
 
@@ -78,7 +78,7 @@
 #endif /* PNGARG */
 
 /* enough people need this for various reasons to include it here */
-#ifndef MACOS
+#if !defined(MACOS) && !defined(RISCOS)
 #include <sys/types.h>
 #endif
 /* need the time information for reading tIME chunks */
@@ -138,11 +138,11 @@
 #endif /* PNG_INTERNAL */
 
 /* the following uses const char * instead of char * for error
-	and warning message functions, so some compilers won't complain.
-	If you want to use const, define PNG_USE_CONST here.  It is not
-	normally defined to make configuration easier, as it is not a
+   and warning message functions, so some compilers won't complain.
+   If you want to use const, define PNG_USE_CONST here.  It is not
+   normally defined to make configuration easier, as it is not a
    critical part of the code.
-	*/
+   */
 
 #ifdef PNG_USE_CONST
 #  define PNG_CONST const
@@ -179,6 +179,7 @@
 #define PNG_READ_FILLER_SUPPORTED
 #define PNG_READ_GAMMA_SUPPORTED
 #define PNG_READ_GRAY_TO_RGB_SUPPORTED
+#undef  PNG_CORRECT_PALETTE_SUPPORTED
 
 #define PNG_WRITE_INTERLACING_SUPPORTED
 #define PNG_WRITE_SHIFT_SUPPORTED
@@ -260,7 +261,7 @@ typedef size_t png_size_t;
 #define FAR __far
 #endif
 #define USE_FAR_KEYWORD
-#endif	/* LDATA != 1 */
+#endif   /* LDATA != 1 */
 
 /* SJT:  Possibly useful for moving data out of default segment.
    Uncomment it if you want. Could also define FARDATA as const
@@ -269,7 +270,7 @@ typedef size_t png_size_t;
 */
 #endif  /* __WIN32__, __FLAT__ */
 
-#endif	/* __BORLANDC__ */
+#endif   /* __BORLANDC__ */
 
 
 /* SJT:  Suggest testing for specific compiler first before
@@ -303,7 +304,7 @@ typedef unsigned char FAR png_bytef;
 /* End medium model changes to be in zconf.h */
 
 /* SJT: More typedefs */
-typedef void FAR *	png_voidp;
+typedef void FAR *   png_voidp;
 
 
 /* SJT: Add typedefs for pointers */
@@ -341,7 +342,7 @@ typedef z_stream *      png_zstreamp; /* zlib won't accept far z_stream */
 #   define png_strcat _fstrcat
 #   define png_strlen _fstrlen
 #   define png_strcmp _fstrcmp
-#   define png_memcmp _fmemcmp		/* SJT: added */
+#   define png_memcmp _fmemcmp      /* SJT: added */
 #   define png_memcpy _fmemcpy
 #   define png_memset _fmemset
 #else /* use the usual functions */
@@ -349,7 +350,7 @@ typedef z_stream *      png_zstreamp; /* zlib won't accept far z_stream */
 #   define png_strcat strcat
 #   define png_strlen strlen
 #   define png_strcmp strcmp
-#   define png_memcmp memcmp		/* SJT: added */
+#   define png_memcmp memcmp     /* SJT: added */
 #   define png_memcpy memcpy
 #   define png_memset memset
 #endif

pngerror.c

@@ -1,107 +1,110 @@
 
 /* pngerror.c - stub functions for i/o and memory allocation
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
 
-	This file provides a location for all error handling.  Users which
+   This file provides a location for all error handling.  Users which
    need special error handling are expected to write replacement functions
-	and use png_set_message_fn() to use those functions.  See the instructions
-	at each function. */
+   and use png_set_error_fn() to use those functions.  See the instructions
+   at each function. */
 
 #define PNG_INTERNAL
 #include "png.h"
 
+static void png_default_error PNGARG((png_structp png_ptr,
+                                      png_const_charp message));
+static void png_default_warning PNGARG((png_structp png_ptr,
+                                        png_const_charp message));
+
 /* This function is called whenever there is a fatal error.  This function
-	should not be changed.  If there is a need to handle errors differently,
-	you should supply a replacement error function and use png_set_message_fn()
+   should not be changed.  If there is a need to handle errors differently,
+   you should supply a replacement error function and use png_set_error_fn()
    to replace the error function at run-time. */
 void
 png_error(png_structp png_ptr, png_const_charp message)
 {
-	if (png_ptr->error_fn)
-		(*(png_ptr->error_fn))(png_ptr, message);
+   if (png_ptr->error_fn)
+      (*(png_ptr->error_fn))(png_ptr, message);
 
-	/* if the following returns or doesn't exist, use the default function,
-	   which will not return */
-	png_default_error(png_ptr, message);
+   /* if the following returns or doesn't exist, use the default function,
+      which will not return */
+   png_default_error(png_ptr, message);
 }
 
 /* This function is called whenever there is a non-fatal error.  This function
-	should not be changed.  If there is a need to handle warnings differently,
-	you should supply a replacement warning function and use
-	png_set_message_fn() to replace the warning function at run-time. */
+   should not be changed.  If there is a need to handle warnings differently,
+   you should supply a replacement warning function and use
+   png_set_error_fn() to replace the warning function at run-time. */
 void
 png_warning(png_structp png_ptr, png_const_charp message)
 {
-	if (png_ptr->warning_fn)
-		(*(png_ptr->warning_fn))(png_ptr, message);
-	else
-		png_default_warning(png_ptr, message);
+   if (png_ptr->warning_fn)
+      (*(png_ptr->warning_fn))(png_ptr, message);
+   else
+      png_default_warning(png_ptr, message);
 }
 
 /* This is the default error handling function.  Note that replacements for
-	this function MUST NOT RETURN, or the program will likely crash.  This
-	function is used by default, or if the program supplies NULL for the
-	error function pointer in png_set_message_fn(). */
-void
+   this function MUST NOT RETURN, or the program will likely crash.  This
+   function is used by default, or if the program supplies NULL for the
+   error function pointer in png_set_error_fn(). */
+static void
 png_default_error(png_structp png_ptr, png_const_charp message)
 {
 #ifndef PNG_NO_STDIO
-	fprintf(stderr, "libpng error: %s\n", message);
+   fprintf(stderr, "libpng error: %s\n", message);
 #endif
 
 #ifdef USE_FAR_KEYWORD
-	{
-		jmp_buf jmpbuf;
-		png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
-		longjmp(jmpbuf, 1);
-	}
+   {
+      jmp_buf jmpbuf;
+      png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
+      longjmp(jmpbuf, 1);
+   }
 #else
-	longjmp(png_ptr->jmpbuf, 1);
+   longjmp(png_ptr->jmpbuf, 1);
 #endif
 }
 
 /* This function is called when there is a warning, but the library thinks
-	it can continue anyway.  Replacement functions don't have to do anything
-	here if you don't want to.  In the default configuration, png_ptr is
+   it can continue anyway.  Replacement functions don't have to do anything
+   here if you don't want to.  In the default configuration, png_ptr is
    not used, but it is passed in case it may be useful. */
-void
+static void
 png_default_warning(png_structp png_ptr, png_const_charp message)
 {
-	if (!png_ptr)
-		return;
+   if (!png_ptr)
+      return;
 
 #ifndef PNG_NO_STDIO
-	fprintf(stderr, "libpng warning: %s\n", message);
+   fprintf(stderr, "libpng warning: %s\n", message);
 #endif
 }
 
 /* This function is called when the application wants to use another method
-	of handling errors and warnings.  Note that the error function MUST NOT
-	return to the calling routine or serious problems will occur. The error
-	return method used in the default routine calls
-	longjmp(png_ptr->jmpbuf, 1) */
+   of handling errors and warnings.  Note that the error function MUST NOT
+   return to the calling routine or serious problems will occur.  The return
+   method used in the default routine calls longjmp(png_ptr->jmpbuf, 1) */
 void
-png_set_message_fn(png_structp png_ptr, png_voidp msg_ptr, png_msg_ptr error_fn,
-	png_msg_ptr warning_fn)
+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warning_fn)
 {
-	png_ptr->msg_ptr = msg_ptr;
-
-	png_ptr->error_fn = error_fn;
-	png_ptr->warning_fn = warning_fn;
+   png_ptr->error_ptr = error_ptr;
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
 }
 
 
-/* This function returns a pointer to the msg_ptr associated with the user
-	functions.  The application should free any memory associated with this
-	pointer before png_write_destroy and png_read_destroy are called. */
+/* This function returns a pointer to the error_ptr associated with the user
+   functions.  The application should free any memory associated with this
+   pointer before png_write_destroy and png_read_destroy are called. */
 png_voidp
-png_get_msg_ptr(png_structp png_ptr)
+png_get_error_ptr(png_structp png_ptr)
 {
-	return png_ptr->msg_ptr;
+   return png_ptr->error_ptr;
 }
 
 

pngio.c

@@ -1,318 +0,0 @@
-
-/* pngio.c - stub functions for i/o and memory allocation
-
-	libpng 1.0 beta 2 - version 0.87
-   For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
-
-   This file provides a location for all input/output.  Users which need
-	special handling are expected to write functions which have the same
-	arguments as these, and perform similar functions, but possibly have
-	different I/O methods.  Note that you shouldn't change these functions,
-	but rather write replacement functions and then change them at run
-	time with png_set_write_fn(...) or png_set_read_fn(...), etc */
-
-#define PNG_INTERNAL
-#include "png.h"
-
-/* Write the data to whatever output you are using.  The default routine
-	writes to a file pointer.  Note that this routine sometimes gets called
-	with very small lengths, so you should implement some kind of simple
-	buffering if you are using unbuffered writes.  This should never be asked
-	to write more then 64K on a 16 bit machine.  The cast to png_size_t is
-	there to quiet warnings of certain compilers. */
-
-void
-png_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
-{
-	if (png_ptr->write_data_fn)
-		(*(png_ptr->write_data_fn))(png_ptr, data, length);
-	else
-		png_error(png_ptr, "Call to NULL write function");
-}
-
-/* This is the function which does the actual writing of data.  If you are
-	not writing to a standard C stream, you should create a replacement
-	write_data function and use it at run time with png_set_write_fn(), rather
-	than changing the library. */
-#ifndef USE_FAR_KEYWORD
-void
-png_default_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
-{
-   png_uint_32 check;
-
-   check = fwrite(data, 1, (png_size_t)length, png_ptr->fp);
-   if (check != length)
-   {
-      png_error(png_ptr, "Write Error");
-   }
-}
-#else
-/* this is the model-independent version. Since the standard I/O library
-   can't handle far buffers in the medium and small models, we have to copy
-	the data.
-*/
-
-#define NEAR_BUF_SIZE 1024
-#define MIN(a,b) (a <= b ? a : b)
-
-#ifdef _MSC_VER
-/* for FP_OFF */
-#include <dos.h>
-#endif
-
-void
-png_default_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
-{
-   png_uint_32 check;
-   png_byte *n_data;
-
-   /* Check if data really is near. If so, use usual code. */
-#ifdef _MSC_VER
-	/* do it this way just to quiet warning */
-   FP_OFF(n_data) = FP_OFF(data);
-	if (FP_SEG(n_data) == FP_SEG(data))
-#else
-	/* this works in MSC also but with lost segment warning */
-   n_data = (png_byte *)data;
-	if ((png_bytep)n_data == data)
-#endif
-   {
-      check = fwrite(n_data, 1, (png_size_t)length, png_ptr->fp);
-   }
-	else
-   {
-      png_byte buf[NEAR_BUF_SIZE];
-      png_size_t written, remaining, err;
-      check = 0;
-      remaining = (png_size_t)length;
-		do
-		{
-			written = MIN(NEAR_BUF_SIZE, remaining);
-			png_memcpy(buf, data, written); /* copy far buffer to near buffer */
-         err = fwrite(buf, 1, written, png_ptr->fp);
-			if (err != written)
-            break;
-			else
-            check += err;
-         data += written;
-         remaining -= written;
-      }
-		while (remaining != 0);
-	}
-	if (check != length)
-	{
-		png_error(png_ptr, "Write Error");
-	}
-}
-
-#endif
-
-/* Read the data from whatever input you are using.  The default routine
-	reads from a file pointer.  Note that this routine sometimes gets called
-	with very small lengths, so you should implement some kind of simple
-	buffering if you are using unbuffered reads.  This should never be asked
-	to read more then 64K on a 16 bit machine.  The cast to png_size_t is
-	there to quiet some compilers */
-void
-png_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
-{
-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
-	if (png_ptr->read_mode == PNG_READ_PUSH_MODE)
-	{
-   	png_push_fill_buffer(png_ptr, data, length);
-	}
-   else
-#endif
-	{
-		if (png_ptr->read_data_fn)
-			(*(png_ptr->read_data_fn))(png_ptr, data, length);
-		else
-			png_error(png_ptr, "Call to NULL read function");
-	}
-}
-
-/* This is the function which does the actual reading of data.  If you are
-	not reading from a standard C stream, you should create a replacement
-	read_data function and use it at run time with png_set_read_fn(), rather
-	than changing the library. */
-#ifndef USE_FAR_KEYWORD
-void
-png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
-{
-   png_uint_32 check;
-
-   check = fread(data, 1, (size_t)length, png_ptr->fp);
-   if (check != length)
-   {
-      png_error(png_ptr, "Read Error");
-   }
-}
-#else
-void
-png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
-{
-   png_uint_32 check;
-   png_byte *n_data;
-
-   /* Check if data really is near. If so, use usual code. */
-#ifdef _MSC_VER
-   /* do it this way just to quiet warning */
-   FP_OFF(n_data) = FP_OFF(data);
-	if (FP_SEG(n_data) == FP_SEG(data))
-#else
-   /* this works in MSC also but with lost segment warning */
-   n_data = (png_byte *)data;
-   if ((png_bytep)n_data == data)
-#endif
-   {
-      check = fread(n_data, 1, (size_t)length, png_ptr->fp);
-	}
-   else
-   {
-      png_byte buf[NEAR_BUF_SIZE];
-      png_size_t read, remaining, err;
-      check = 0;
-      remaining = (png_size_t)length;
-      do
-      {
-			read = MIN(NEAR_BUF_SIZE, remaining);
-         err = fread(buf, 1, read, png_ptr->fp);
-			png_memcpy(data, buf, read); /* copy far buffer to near buffer */
-         if(err != read)
-            break;
-         else
-            check += err;
-         data += read;
-			remaining -= read;
-		}
-		while (remaining != 0);
-	}
-	if (check != length)
-	{
-		png_error(png_ptr, "read Error");
-	}
-}
-#endif
-
-/* This function is called to output any data pending writing (normally
-	to disk.  After png_flush is called, there should be no data pending
-	writing in any buffers. */
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
-void
-png_flush(png_structp png_ptr)
-{
-	if (png_ptr->output_flush_fn)
-		(*(png_ptr->output_flush_fn))(png_ptr);
-}
-
-void
-png_default_flush(png_structp png_ptr)
-{
-	if (png_ptr->fp)
-		fflush(png_ptr->fp);
-}
-#endif
-
-/* This function allows the application to supply new output functions for
-	libpng if standard C streams aren't being used.
-
-	This function takes as its arguments:
-	png_ptr       - pointer to a png output data structure
-	io_ptr        - pointer to user supplied structure containing info about
-						 the output functions.  May be NULL.
-	write_data_fn - pointer to a new output function which takes as its
-						 arguments a pointer to a png_struct, a pointer to
-						 data to be written, and a 32-bit unsigned int which is
-						 the number of bytes to be written.  The new write
-						 function should call png_error(png_ptr, "Error msg")
-						 to exit and output any fatal error messages.
-	flush_data_fn - pointer to a new flush function which takes as its
-						 arguments a pointer to a png_struct.  After a call to
-						 the flush function, there should be no data in any buffers
-						 or pending transmission.  If the output method doesn't do
-						 any buffering of ouput, a function prototype must still be
-						 supplied although it doesn't have to do anything.  If
-						 PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
-						 time, output_flush_fn will be ignored, although it must be
-						 supplied for compatibility. */
-void
-png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
-	png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
-{
-	png_ptr->io_ptr = io_ptr;
-
-	if (write_data_fn)
-		png_ptr->write_data_fn = write_data_fn;
-	else
-		png_ptr->write_data_fn = png_default_write_data;
-
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
-	if (output_flush_fn)
-		png_ptr->output_flush_fn = output_flush_fn;
-	else
-		png_ptr->output_flush_fn = png_default_flush;
-#endif /* PNG_WRITE_FLUSH_SUPPORTED */
-
-	/* It is an error to read while writing a png file */
-	png_ptr->read_data_fn = NULL;
-}
-
-
-/* This function allows the application to supply a new input function
-	for libpng if standard C streams aren't being used.
-
-	This function takes as its arguments:
-	png_ptr      - pointer to a png input data structure
-	io_ptr       - pointer to user supplied structure containing info about
-						the input functions.  May be NULL.
-	read_data_fn - pointer to a new input function which takes as it's
-						arguments a pointer to a png_struct, a pointer to
-						a location where input data can be stored, and a 32-bit
-						unsigned int which is the number of bytes to be read.
-						To exit and output any fatal error messages the new write
-                  function should call png_error(png_ptr, "Error msg"). */
-void
-png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
-	png_rw_ptr read_data_fn)
-{
-	png_ptr->io_ptr = io_ptr;
-
-	if (read_data_fn)
-		png_ptr->read_data_fn = read_data_fn;
-	else
-		png_ptr->read_data_fn = png_default_read_data;
-
-	/* It is an error to write to a read device */
-	png_ptr->write_data_fn = NULL;
-
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
-	png_ptr->output_flush_fn = NULL;
-#endif /* PNG_WRITE_FLUSH_SUPPORTED */
-}
-
-
-/* This function returns a pointer to the io_ptr associated with the user
-	functions.  The application should free any memory associated with this
-	pointer before png_write_destroy and png_read_destroy are called. */
-png_voidp
-png_get_io_ptr(png_structp png_ptr)
-{
-	return png_ptr->io_ptr;
-}
-
-/* Initialize the default input/output functions for the png file.  If you
-	change the read, or write routines, you can call either png_set_read_fn()
-   or png_set_write_fn() instead of png_init_io(). */
-void
-png_init_io(png_structp png_ptr, FILE *fp)
-{
-	png_ptr->fp = fp;
-	png_ptr->read_data_fn = png_default_read_data;
-	png_ptr->write_data_fn = png_default_write_data;
-#ifdef PNG_WRITE_FLUSH_SUPPORTED
-	png_ptr->output_flush_fn = png_default_flush;
-#endif
-}
-

pngmem.c

@@ -1,14 +1,14 @@
 
 /* pngmem.c - stub functions for memory allocation
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
 
    This file provides a location for all memory allocation.  Users which
-	need special memory handling are expected to modify the code in this file
-	to meet their needs.  See the instructions at each function. */
+   need special memory handling are expected to modify the code in this file
+   to meet their needs.  See the instructions at each function. */
 
 #define PNG_INTERNAL
 #include "png.h"
@@ -17,191 +17,147 @@
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 /* if you change this, be sure to change the one in png.h also */
 
+/* Allocate memory for a png_struct.  The malloc and memset can be replaced
+ * by a single call to calloc() if this is thought to improve performance.
+ */
+png_voidp
+png_create_struct(uInt type)
+{
+   png_size_t type;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+     size = sizeof(png_info);
+   else if (type == PNG_STRUCT_PNG)
+     size = sizeof(png_struct);
+   else
+     return (png_voidp)NULL;
+
+   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
+   {
+      png_memset(struct_ptr, 0, size);
+   }
+
+   return (struct_ptr);
+}
+
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct(png_voidp struct_ptr)
+{
+   if (struct_ptr)
+      farfree (struct_ptr);
+}
+
 /* Allocate memory.  For reasonable files, size should never exceed
-	64K.  However, zlib may allocate more then 64K if you don't tell
-	it not to.  See zconf.h and png.h for more information. zlib does
-	need to allocate exactly 64K, so whatever you call here must
-	have the ability to do that. */
+   64K.  However, zlib may allocate more then 64K if you don't tell
+   it not to.  See zconf.h and png.h for more information. zlib does
+   need to allocate exactly 64K, so whatever you call here must
+   have the ability to do that. */
 
 /* Borland seems to have a problem in DOS mode for exactly 64K.
-	It gives you a segment with an offset of 8 (perhaps to store it's
-	memory stuff).  zlib doesn't like this at all, so we have to
-	detect and deal with it.  This code should not be needed in
-   Windows or OS/2 modes, and only in 16 bit mode.
+   It gives you a segment with an offset of 8 (perhaps to store it's
+   memory stuff).  zlib doesn't like this at all, so we have to
+   detect and deal with it.  This code should not be needed in
+   Windows or OS/2 modes, and only in 16 bit mode.  This code has
+   been updated by Alexander Lehmann for version 0.89 to waste less
+   memory.
 */
 
 png_voidp
 png_large_malloc(png_structp png_ptr, png_uint_32 size)
 {
-	png_voidp ret;
-	if (!png_ptr || !size)
-		return ((voidp)0);
+   png_voidp ret;
+   if (!png_ptr || !size)
+      return ((voidp)NULL);
 
 #ifdef PNG_MAX_MALLOC_64K
-	if (size > (png_uint_32)65536L)
-		png_error(png_ptr, "Cannot Allocate > 64K");
+   if (size > (png_uint_32)65536L)
+      png_error(png_ptr, "Cannot Allocate > 64K");
 #endif
 
-	if (size == (png_uint_32)(65536L))
-	{
-		if (!png_ptr->offset_table)
-		{
-			/* try to see if we need to do any of this fancy stuff */
-			ret = farmalloc(size);
-			if (!ret || ((long)ret & 0xffff))
-			{
-				int num_blocks;
-				png_uint_32 total_size;
-				png_bytep table;
-				int i;
+   if (size == (png_uint_32)(65536L))
+   {
+      if (!png_ptr->offset_table)
+      {
+         /* try to see if we need to do any of this fancy stuff */
+         ret = farmalloc(size);
+         if (!ret || ((long)ret & 0xffff))
+         {
+            int num_blocks;
+            png_uint_32 total_size;
+            png_bytep table;
+            int i;
             png_byte huge * hptr;
 
-				if (ret)
-					farfree(ret);
-				ret = 0;
+            if (ret)
+               farfree(ret);
+            ret = NULL;
 
-				num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
-				if (num_blocks < 1)
-					num_blocks = 1;
-				if (png_ptr->zlib_mem_level >= 7)
-					num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
-				else
-            	num_blocks++;
+            num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
+            if (num_blocks < 1)
+               num_blocks = 1;
+            if (png_ptr->zlib_mem_level >= 7)
+               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
+            else
+               num_blocks++;
 
-				total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks;
+            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
 
-				table = farmalloc(total_size);
+            table = farmalloc(total_size);
 
-				if (!table)
-				{
-					png_error(png_ptr, "Out of Memory");
-				}
-
-				if ((long)table & 0xffff)
-				{
-					farfree(table);
-					total_size += (png_uint_32)65536L;
-				}
-
-				table = farmalloc(total_size);
-
-				if (!table)
-				{
-					png_error(png_ptr, "Out of Memory");
-				}
-
-				png_ptr->offset_table = table;
-				png_ptr->offset_table_ptr = farmalloc(
-					num_blocks * sizeof (png_bytep));
-				hptr = (png_byte huge *)table;
-				if ((long)hptr & 0xffff)
-				{
-					hptr = (png_byte huge *)((long)(hptr) & 0xffff0000L);
-					hptr += 65536L;
-				}
-				for (i = 0; i < num_blocks; i++)
-				{
-					png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
-					hptr += 65536L;
-				}
-
-				png_ptr->offset_table_number = num_blocks;
-				png_ptr->offset_table_count = 0;
-				png_ptr->offset_table_count_free = 0;
-			}
-
-			if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
-				png_error(png_ptr, "Out of Memory");
-
-         ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
-		}
-	}
-	else
-		ret = farmalloc(size);
-
-	if (ret == NULL)
-	{
-		png_error(png_ptr, "Out of Memory");
-	}
-
-	return ret;
-}
-
-/* free a pointer allocated by png_large_malloc().  In the default
-  configuration, png_ptr is not used, but is passed in case it
-  is needed.  If ptr is NULL, return without taking any action. */
-void
-png_large_free(png_structp png_ptr, png_voidp ptr)
-{
-	if (!png_ptr)
-		return;
-
-	if (ptr != NULL)
-	{
-		if (png_ptr->offset_table)
-		{
-			int i;
-
-			for (i = 0; i < png_ptr->offset_table_count; i++)
-			{
-				if (ptr == png_ptr->offset_table_ptr[i])
+            if (!table)
             {
-					ptr = 0;
-               png_ptr->offset_table_count_free++;
-					break;
-				}
-			}
-			if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
-			{
-				farfree(png_ptr->offset_table);
-				farfree(png_ptr->offset_table_ptr);
-				png_ptr->offset_table = 0;
-				png_ptr->offset_table_ptr = 0;
+               png_error(png_ptr, "Out of Memory");
+            }
+
+            if ((long)table & 0xfff0)
+            {
+               png_error(png_ptr, "Farmalloc didn't return normalized pointer");
+            }
+
+            png_ptr->offset_table = table;
+            png_ptr->offset_table_ptr = farmalloc(
+               num_blocks * sizeof (png_bytep));
+
+            if (!png_ptr->offset_table_ptr)
+            {
+               png_error(png_ptr, "Out of memory");
+            }
+
+            hptr = (png_byte huge *)table;
+            if ((long)hptr & 0xf)
+            {
+               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+               hptr += 16L;
+            }
+            for (i = 0; i < num_blocks; i++)
+            {
+               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+               hptr += 65536L;
+            }
+
+            png_ptr->offset_table_number = num_blocks;
+            png_ptr->offset_table_count = 0;
+            png_ptr->offset_table_count_free = 0;
          }
-		}
+      }
 
-		if (ptr)
-			farfree(ptr);
-	}
-}
+      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
+         png_error(png_ptr, "Out of Memory");
 
-#else /* Not the Borland DOS special memory handler */
-
-/* Allocate memory.  For reasonable files, size should never exceed
-	64K.  However, zlib may allocate more then 64K if you don't tell
-	it not to.  See zconf.h and png.h for more information. zlib does
-	need to allocate exactly 64K, so whatever you call here must
-	have the ability to do that. */
-
-
-png_voidp
-png_large_malloc(png_structp png_ptr, png_uint_32 size)
-{
-	png_voidp ret;
-	if (!png_ptr || !size)
-		return ((voidp)0);
-
-#ifdef PNG_MAX_MALLOC_64K
-	if (size > (png_uint_32)65536L)
-		png_error(png_ptr, "Cannot Allocate > 64K");
-#endif
-
-#if defined(__TURBOC__) && !defined(__FLAT__)
-	ret = farmalloc(size);
-#else
-# if defined(_MSC_VER) && defined(MAXSEG_64K)
-	ret = halloc(size, 1);
-# else
-	ret = malloc(size);
-# endif
-#endif
+      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
+   }
+   else
+      ret = farmalloc(size);
 
    if (ret == NULL)
    {
       png_error(png_ptr, "Out of Memory");
    }
 
-	return ret;
+   return ret;
 }
 
 /* free a pointer allocated by png_large_malloc().  In the default
@@ -211,29 +167,156 @@ void
 png_large_free(png_structp png_ptr, png_voidp ptr)
 {
    if (!png_ptr)
-		return;
+      return;
+
+   if (ptr != NULL)
+   {
+      if (png_ptr->offset_table)
+      {
+         int i;
+
+         for (i = 0; i < png_ptr->offset_table_count; i++)
+         {
+            if (ptr == png_ptr->offset_table_ptr[i])
+            {
+               ptr = 0;
+               png_ptr->offset_table_count_free++;
+               break;
+            }
+         }
+         if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
+         {
+            farfree(png_ptr->offset_table);
+            farfree(png_ptr->offset_table_ptr);
+            png_ptr->offset_table = 0;
+            png_ptr->offset_table_ptr = 0;
+         }
+      }
+
+      if (ptr)
+         farfree(ptr);
+   }
+}
+
+#else /* Not the Borland DOS special memory handler */
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+ * memset can be replaced by a single call to calloc() if this is thought
+ * to improve performance noticably.
+ */
+png_voidp
+png_create_struct(uInt type)
+{
+   size_t size;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+     size = sizeof(png_info);
+   else if (type == PNG_STRUCT_PNG)
+     size = sizeof(png_struct);
+   else
+     return (png_voidp)NULL;
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   if ((struct_ptr = (png_voidp)halloc(size,1)) != NULL)
+# else
+   if ((struct_ptr = (png_voidp)malloc(size)) != NULL)
+# endif
+#endif
+   {
+      png_memset(struct_ptr, 0, size);
+   }
+
+   return (struct_ptr);
+}
+
+
+/* Free memory allocated by a png_create_struct() call */
+void
+png_destroy_struct(png_voidp struct_ptr)
+{
+   if (struct_ptr)
+#if defined(__TURBOC__) && !defined(__FLAT__)
+      farfree(struct_ptr);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+      hfree(struct_ptr);
+# else
+      free(struct_ptr);
+# endif
+#endif
+}
+
+
+/* Allocate memory.  For reasonable files, size should never exceed
+   64K.  However, zlib may allocate more then 64K if you don't tell
+   it not to.  See zconf.h and png.h for more information. zlib does
+   need to allocate exactly 64K, so whatever you call here must
+   have the ability to do that. */
+
+png_voidp
+png_large_malloc(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ret;
+   if (!png_ptr || !size)
+      return ((voidp)0);
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (size > (png_uint_32)65536L)
+      png_error(png_ptr, "Cannot Allocate > 64K");
+#endif
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   ret = farmalloc(size);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   ret = halloc(size, 1);
+# else
+   ret = malloc(size);
+# endif
+#endif
+
+   if (ret == NULL)
+   {
+      png_error(png_ptr, "Out of Memory");
+   }
+
+   return ret;
+}
+
+/* free a pointer allocated by png_large_malloc().  In the default
+  configuration, png_ptr is not used, but is passed in case it
+  is needed.  If ptr is NULL, return without taking any action. */
+void
+png_large_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (!png_ptr)
+      return;
 
    if (ptr != NULL)
    {
 #if defined(__TURBOC__) && !defined(__FLAT__)
-		farfree(ptr);
+      farfree(ptr);
 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)
-		hfree(ptr);
+      hfree(ptr);
 # else
-		free(ptr);
+      free(ptr);
 # endif
 #endif
-	}
+   }
 }
 
 #endif /* Not Borland DOS special memory handler */
 
 /* Allocate memory.  This is called for smallish blocks only  It
-	should not get anywhere near 64K.  On segmented machines, this
-	must come from the local heap (for zlib).  Currently, zlib is
-	the only one that uses this, so you should only get one call
-	to this, and that a small block. */
+   should not get anywhere near 64K.  On segmented machines, this
+   must come from the local heap (for zlib).  Currently, zlib is
+   the only one that uses this, so you should only get one call
+   to this, and that a small block. */
 void *
 png_malloc(png_structp png_ptr, png_uint_32 size)
 {
@@ -252,39 +335,39 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
 
    ret = malloc((png_size_t)size);
 
-	if (!ret)
+   if (!ret)
    {
-		png_error(png_ptr, "Out of Memory");
+      png_error(png_ptr, "Out of Memory");
    }
 
    return ret;
 }
 
 /* Reallocate memory.  This will not get near 64K on a
-	even marginally reasonable file.  This is not used in
-	the current version of the library. */
+   even marginally reasonable file.  This is not used in
+   the current version of the library. */
 void *
 png_realloc(png_structp png_ptr, void * ptr, png_uint_32 size,
-	png_uint_32 old_size)
+   png_uint_32 old_size)
 {
-	void *ret;
+   void *ret;
 
-	if (!png_ptr || !old_size || !ptr || !size)
-		return ((void *)0);
+   if (!png_ptr || !old_size || !ptr || !size)
+      return ((void *)0);
 
 #ifdef PNG_MAX_MALLOC_64K
-	if (size > (png_uint_32)65536L)
-		png_error(png_ptr, "Cannot Allocate > 64K");
+   if (size > (png_uint_32)65536L)
+      png_error(png_ptr, "Cannot Allocate > 64K");
 #endif
 
-	ret = realloc(ptr, (png_size_t)size);
+   ret = realloc(ptr, (png_size_t)size);
 
-	if (!ret)
-	{
-		png_error(png_ptr, "Out of Memory 7");
-	}
+   if (!ret)
+   {
+      png_error(png_ptr, "Out of Memory 7");
+   }
 
-	return ret;
+   return ret;
 }
 
 /* free a pointer allocated by png_malloc().  In the default
@@ -293,11 +376,10 @@ png_realloc(png_structp png_ptr, void * ptr, png_uint_32 size,
 void
 png_free(png_structp png_ptr, void * ptr)
 {
-	if (!png_ptr)
-		return;
+   if (!png_ptr)
+      return;
 
-	if (ptr != (void *)0)
-		free(ptr);
+   if (ptr != (void *)0)
+      free(ptr);
 }
 
-

pngrcb.c

@@ -1,9 +1,9 @@
 /* pngrcb.c - callbacks while reading a png file
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
    */
 
 #define PNG_INTERNAL
@@ -20,11 +20,11 @@ png_read_IHDR(png_structp png_ptr, png_infop info,
 
    info->width = width;
    info->height = height;
-	info->bit_depth = (png_byte)bit_depth;
-	info->color_type =(png_byte) color_type;
-	info->compression_type = (png_byte)compression_type;
-	info->filter_type = (png_byte)filter_type;
-	info->interlace_type = (png_byte)interlace_type;
+   info->bit_depth = (png_byte)bit_depth;
+   info->color_type =(png_byte) color_type;
+   info->compression_type = (png_byte)compression_type;
+   info->filter_type = (png_byte)filter_type;
+   info->interlace_type = (png_byte)interlace_type;
    if (info->color_type == PNG_COLOR_TYPE_PALETTE)
       info->channels = 1;
    else if (info->color_type & PNG_COLOR_MASK_COLOR)
@@ -33,7 +33,7 @@ png_read_IHDR(png_structp png_ptr, png_infop info,
       info->channels = 1;
    if (info->color_type & PNG_COLOR_MASK_ALPHA)
       info->channels++;
-	info->pixel_depth = (png_byte)(info->channels * info->bit_depth);
+   info->pixel_depth = (png_byte)(info->channels * info->bit_depth);
    info->rowbytes = ((info->width * info->pixel_depth + 7) >> 3);
 }
 
@@ -45,7 +45,7 @@ png_read_PLTE(png_structp png_ptr, png_infop info,
       return;
 
    info->palette = palette;
-	info->num_palette = (png_uint_16)num;
+   info->num_palette = (png_uint_16)num;
    info->valid |= PNG_INFO_PLTE;
 }
 
@@ -69,7 +69,7 @@ png_read_sBIT(png_structp png_ptr, png_infop info,
    if (!png_ptr || !info)
       return;
 
-	png_memcpy(&(info->sig_bit), sig_bit, sizeof (png_color_8));
+   png_memcpy(&(info->sig_bit), sig_bit, sizeof (png_color_8));
    info->valid |= PNG_INFO_sBIT;
 }
 #endif
@@ -77,8 +77,8 @@ png_read_sBIT(png_structp png_ptr, png_infop info,
 #if defined(PNG_READ_cHRM_SUPPORTED)
 void
 png_read_cHRM(png_structp png_ptr, png_infop info,
-	double white_x, double white_y, double red_x, double red_y,
-	double green_x, double green_y, double blue_x, double blue_y)
+   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 || !info)
       return;
@@ -112,7 +112,7 @@ png_read_tRNS(png_structp png_ptr, png_infop info,
       png_memcpy(&(info->trans_values), trans_values,
          sizeof(png_color_16));
    }
-	info->num_trans = (png_uint_16)num_trans;
+   info->num_trans = (png_uint_16)num_trans;
    info->valid |= PNG_INFO_tRNS;
 }
 #endif
@@ -152,7 +152,7 @@ png_read_pHYs(png_structp png_ptr, png_infop info,
 
    info->x_pixels_per_unit = res_x;
    info->y_pixels_per_unit = res_y;
-	info->phys_unit_type = (png_byte)unit_type;
+   info->phys_unit_type = (png_byte)unit_type;
    info->valid |= PNG_INFO_pHYs;
 }
 #endif
@@ -175,7 +175,7 @@ png_read_oFFs(png_structp png_ptr, png_infop info,
 #if defined(PNG_READ_tIME_SUPPORTED)
 void
 png_read_tIME(png_structp png_ptr, png_infop info,
-	png_timep mod_time)
+   png_timep mod_time)
 {
    if (!png_ptr || !info)
       return;
@@ -185,7 +185,7 @@ png_read_tIME(png_structp png_ptr, png_infop info,
 }
 #endif
 
-#if defined(PNG_READ_zTXt_SUPPORTED)
+#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
 void
 png_read_zTXt(png_structp png_ptr, png_infop info,
    png_charp key, png_charp text, png_uint_32 text_len, int compression)
@@ -193,31 +193,31 @@ png_read_zTXt(png_structp png_ptr, png_infop info,
    if (!png_ptr || !info)
       return;
 
-	if (info->max_text <= info->num_text)
+   if (info->max_text <= info->num_text)
    {
       if (info->text)
       {
          png_uint_32 old_max;
 
          old_max = info->max_text;
-			info->max_text = info->num_text + 16;
-			{
-				png_textp old_text;
+         info->max_text = info->num_text + 16;
+         {
+            png_textp old_text;
 
-				old_text = info->text;
-				info->text = (png_textp)png_large_malloc(png_ptr,
-					info->max_text * sizeof (png_text));
-				png_memcpy(info->text, old_text,
-					(png_size_t)(old_max * sizeof (png_text)));
-				png_large_free(png_ptr, old_text);
-			}
+            old_text = info->text;
+            info->text = (png_textp)png_large_malloc(png_ptr,
+               info->max_text * sizeof (png_text));
+            png_memcpy(info->text, old_text,
+               (png_size_t)(old_max * sizeof (png_text)));
+            png_large_free(png_ptr, old_text);
+         }
       }
       else
       {
-         info->max_text = info->num_text + 16;
+         info->max_text = 16;
+         info->num_text = 0;
          info->text = (png_textp)png_large_malloc(png_ptr,
             info->max_text * sizeof (png_text));
-         info->num_text = 0;
       }
    }
 
@@ -237,7 +237,7 @@ png_read_tEXt(png_structp png_ptr, png_infop info,
    if (!png_ptr || !info)
       return;
 
-	png_read_zTXt(png_ptr, info, key, text, text_len, -1);
+   png_read_zTXt(png_ptr, info, key, text, text_len, -1);
 }
 #endif
 

pngread.c

@@ -1,45 +1,116 @@
 
 /* pngread.c - read a png file
 
-   libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
    Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   May 25, 1996
    */
 
 #define PNG_INTERNAL
 #include "png.h"
 
-/* initialize png structure for reading, and allocate any memory needed */
-void
-png_read_init(png_structp png_ptr)
+/* Create a png structure for reading, and allocate any memory needed. */
+png_structp
+png_create_read_struct(png_const_charp user_png_ver, voidp error_ptr,
+   png_error_ptr warn_fn, png_error_ptr error_fn)
 {
-   jmp_buf tmp_jmp;
-   png_msg_ptr error_fn;
-   png_msg_ptr warning_fn;
-   png_voidp msg_ptr;
+   png_structp png_ptr;
 
-   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
-   error_fn = png_ptr->error_fn;
-   warning_fn = png_ptr->warning_fn;
-   msg_ptr = png_ptr->msg_ptr;
+   if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
+   {
+      return (png_structp)NULL;
+   }
 
-   png_memset(png_ptr, 0, sizeof (png_struct));
+   if (setjmp(png_ptr->jmpbuf))
+   {
+      png_large_free(png_ptr, png_ptr->zbuf);
+      png_free(png_ptr, png_ptr->zstream);
+      png_destroy_struct(png_ptr);
+      return (png_structp)NULL;
+   }
 
-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
-   png_ptr->error_fn = error_fn;
-   png_ptr->warning_fn = warning_fn;
-   png_ptr->msg_ptr = msg_ptr;
+   png_set_error_fn(png_ptr, error_ptr, warn_fn, error_fn);
 
+   if (user_png_ver == NULL || strcmp(user_png_ver, png_libpng_ver))
+   {
+      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0])
+      {
+         png_error(png_ptr, "Incompatible libpng versions");
+      }
+      else
+      {
+         png_warning(png_ptr, "Different libpng versions");
+      }
+   }
+
+   /* initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
    png_ptr->zbuf = png_large_malloc(png_ptr, png_ptr->zbuf_size);
+
    png_ptr->zstream = (z_stream *)png_malloc(png_ptr, sizeof (z_stream));
    png_ptr->zstream->zalloc = png_zalloc;
    png_ptr->zstream->zfree = png_zfree;
    png_ptr->zstream->opaque = (voidpf)png_ptr;
-   inflateInit(png_ptr->zstream);
+
+   switch (inflateInit(png_ptr->zstream))
+   {
+     case Z_OK: /* Do nothing */ break;
+     case Z_MEM_ERROR:
+     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
+     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;
+     default: png_error(png_ptr, "Unknown zlib error");
+   }
+
    png_ptr->zstream->next_out = png_ptr->zbuf;
    png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
+
+   png_set_read_fn(png_ptr, NULL, NULL);
+
+   png_ptr->do_free |= PNG_FREE_STRUCT;
+
+   return (png_ptr);
+}
+
+
+/* initialize png structure for reading, and allocate any memory needed */
+/* This interface is depreciated in favour of the png_create_read_struct() */
+void
+png_read_init(png_structp png_ptr)
+{
+   jmp_buf tmp_jmp;  /* to save current jump buffer */
+
+   /* save jump buffer and error functions */
+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
+
+   /* reset all variables to 0 */
+   png_memset(png_ptr, 0, sizeof (png_struct));
+
+   /* restore jump buffer */
+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
+
+   /* initialize zbuf - compression buffer */
+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+   png_ptr->zbuf = png_large_malloc(png_ptr, png_ptr->zbuf_size);
+
+   png_ptr->zstream = (z_stream *)png_malloc(png_ptr, sizeof (z_stream));
+   png_ptr->zstream->zalloc = png_zalloc;
+   png_ptr->zstream->zfree = png_zfree;
+   png_ptr->zstream->opaque = (voidpf)png_ptr;
+
+   switch (inflateInit(png_ptr->zstream))
+   {
+     case Z_OK: /* Do nothing */ break;
+     case Z_MEM_ERROR:
+     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;
+     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;
+     default: png_error(png_ptr, "Unknown zlib error");
+   }
+
+   png_ptr->zstream->next_out = png_ptr->zbuf;
+   png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
+
+   png_set_read_fn(png_ptr, NULL, NULL);
 }
 
 /* read the information before the actual image data. */
@@ -50,8 +121,13 @@ png_read_info(png_structp png_ptr, png_infop info)
    png_uint_32 length;
 
    png_read_data(png_ptr, chunk_start, 8);
-   if (png_memcmp(chunk_start, png_sig, 8))
-      png_error(png_ptr, "Not a Png File");
+   if (!png_check_sig(chunk_start, 8))
+   {
+      if (!png_check_sig(chunk_start, 4))
+         png_error(png_ptr, "Not a PNG file");
+      else
+         png_error(png_ptr, "PNG file corrupted by ASCII conversion");
+   }
 
    while (1)
    {
@@ -62,167 +138,110 @@ png_read_info(png_structp png_ptr, png_infop info)
       png_reset_crc(png_ptr);
       png_calculate_crc(png_ptr, chunk_start + 4, 4);
       if (!png_memcmp(chunk_start + 4, png_IHDR, 4))
-      {
-         if (png_ptr->mode != PNG_BEFORE_IHDR)
-            png_error(png_ptr, "Out of Place IHDR");
-
          png_handle_IHDR(png_ptr, info, length);
-         png_ptr->mode = PNG_HAVE_IHDR;
-      }
       else if (!png_memcmp(chunk_start + 4, png_PLTE, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR)
-            png_error(png_ptr, "Missing IHDR");
-
-#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
-         if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
-            png_crc_skip(png_ptr, length);
-         else
-#else
-         {
-            png_handle_PLTE(png_ptr, info, length);
-         }
-#endif
-         png_ptr->mode = PNG_HAVE_PLTE;
-      }
+         png_handle_PLTE(png_ptr, info, length);
       else if (!png_memcmp(chunk_start + 4, png_IDAT, 4))
       {
+         if (!(png_ptr->mode & PNG_HAVE_IHDR))
+            png_error(png_ptr, "Missing IHDR before IDAT");
+         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+                  !(png_ptr->mode & PNG_HAVE_PLTE))
+            png_error(png_ptr, "Missing PLTE before IDAT");
+
          png_ptr->idat_size = length;
-         png_ptr->mode = PNG_HAVE_IDAT;
+         png_ptr->mode |= PNG_HAVE_IDAT;
          break;
       }
       else if (!png_memcmp(chunk_start + 4, png_IEND, 4))
-      {
-         png_error(png_ptr, "No Image in File");
-      }
+         png_error(png_ptr, "No image in file");
 #if defined(PNG_READ_gAMA_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_gAMA, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR)
-            png_error(png_ptr, "Out of Place PLTE");
-
          png_handle_gAMA(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_sBIT_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_sBIT, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR)
-            png_error(png_ptr, "Out of Place sBIT");
-
          png_handle_sBIT(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_cHRM_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_cHRM, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR)
-            png_error(png_ptr, "Out of Place cHRM");
-
          png_handle_cHRM(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_tRNS_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_tRNS, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR &&
-            png_ptr->mode != PNG_HAVE_PLTE)
-            png_error(png_ptr, "Out of Place tRNS");
-
          png_handle_tRNS(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_bKGD_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_bKGD, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR &&
-            png_ptr->mode != PNG_HAVE_PLTE)
-            png_error(png_ptr, "Out of Place bKGD");
-
          png_handle_bKGD(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_hIST_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_hIST, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_PLTE)
-            png_error(png_ptr, "Out of Place hIST");
-
          png_handle_hIST(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_pHYs_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_pHYs, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR &&
-            png_ptr->mode != PNG_HAVE_PLTE)
-            png_error(png_ptr, "Out of Place pHYs");
-
          png_handle_pHYs(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_oFFs_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_oFFs, 4))
-      {
-         if (png_ptr->mode != PNG_HAVE_IHDR &&
-            png_ptr->mode != PNG_HAVE_PLTE)
-            png_error(png_ptr, "Out of Place oFFs");
-
          png_handle_oFFs(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_tIME_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_tIME, 4))
-      {
-         if (png_ptr->mode == PNG_BEFORE_IHDR ||
-            png_ptr->mode == PNG_AFTER_IEND)
-            png_error(png_ptr, "Out of Place tIME");
-
          png_handle_tIME(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_tEXt_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_tEXt, 4))
-      {
-         if (png_ptr->mode == PNG_BEFORE_IHDR ||
-            png_ptr->mode == PNG_AFTER_IEND)
-            png_error(png_ptr, "Out of Place tEXt");
-
          png_handle_tEXt(png_ptr, info, length);
-      }
 #endif
 #if defined(PNG_READ_zTXt_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_zTXt, 4))
-      {
-         if (png_ptr->mode == PNG_BEFORE_IHDR ||
-            png_ptr->mode == PNG_AFTER_IEND)
-            png_error(png_ptr, "Out of Place zTXt");
-
          png_handle_zTXt(png_ptr, info, length);
-      }
 #endif
       else
       {
+         if (chunk_start[4] < 41 || chunk_start[4] > 122  ||
+             (chunk_start[4] > 90 && chunk_start[4] < 97) ||
+             chunk_start[5] < 41 || chunk_start[5] > 122  ||
+             (chunk_start[5] > 90 && chunk_start[5] < 97) ||
+             chunk_start[6] < 41 || chunk_start[6] > 122  ||
+             (chunk_start[6] > 90 && chunk_start[6] < 97) ||
+             chunk_start[7] < 41 || chunk_start[7] > 122  ||
+             (chunk_start[7] > 90 && chunk_start[7] < 97))
+         {
+            char msg[45];
+
+            sprintf(msg, "Invalid chunk type 0x%02X 0x%02X 0x%02X 0x%02X",
+               chunk_start[4], chunk_start[5], chunk_start[6], chunk_start[7]);
+            png_error(png_ptr, msg);
+         }
+
          if ((chunk_start[4] & 0x20) == 0)
-            png_error(png_ptr, "Unknown Critical Chunk");
+         {
+            char msg[40];
+
+            sprintf(msg, "Unknown critical chunk %c%c%c%c",
+               chunk_start[4], chunk_start[5], chunk_start[6], chunk_start[7]);
+            png_error(png_ptr, msg);
+         }
 
          png_crc_skip(png_ptr, length);
       }
       png_read_data(png_ptr, chunk_start, 4);
       crc = png_get_uint_32(chunk_start);
-      if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
-         (png_ptr->crc & 0xffffffffL))
+      if (((crc ^ 0xffffffffL) & 0xffffffffL) != (png_ptr->crc & 0xffffffffL))
          png_error(png_ptr, "Bad CRC value");
    }
 }
 
 /* optional call to update the users info structure */
 void
-png_read_update_info(png_structp png_ptr, png_infop info_ptr)
+png_read_update_info(png_structp png_ptr, png_infop info)
 {
-   if (!(png_ptr->row_init))
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
       png_read_start_row(png_ptr);
-   png_read_transform_info(png_ptr, info_ptr);
+   png_read_transform_info(png_ptr, info);
 }
 
 /* initialize palette, background, etc, after transformations
@@ -232,7 +251,7 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
 void
 png_start_read_image(png_structp png_ptr)
 {
-   if (!(png_ptr->row_init))
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
       png_read_start_row(png_ptr);
 }
 
@@ -240,7 +259,7 @@ void
 png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
 {
    int ret;
-   if (!(png_ptr->row_init))
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
       png_read_start_row(png_ptr);
 
 #if defined(PNG_READ_INTERLACING_SUPPORTED)
@@ -320,8 +339,8 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
    }
 #endif
 
-   if (png_ptr->mode != PNG_HAVE_IDAT)
-      png_error(png_ptr, "invalid attempt to read row data");
+   if (!(png_ptr->mode & PNG_HAVE_IDAT))
+      png_error(png_ptr, "Invalid attempt to read row data");
 
    png_ptr->zstream->next_out = png_ptr->row_buf;
    png_ptr->zstream->avail_out = (uInt)png_ptr->irowbytes;
@@ -346,8 +365,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
 
             png_crc_read(png_ptr, buf, 4);
             if (png_memcmp(buf, png_IDAT, 4))
-               png_error(png_ptr, "Not enough image data");
-
+               png_error(png_ptr, "Not enough IDATs for image");
          }
          png_ptr->zstream->avail_in = (uInt)png_ptr->zbuf_size;
          png_ptr->zstream->next_in = png_ptr->zbuf;
@@ -362,17 +380,15 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
          if (png_ptr->zstream->avail_out || png_ptr->zstream->avail_in ||
             png_ptr->idat_size)
             png_error(png_ptr, "Extra compressed data");
-         png_ptr->mode = PNG_AT_LAST_IDAT;
+         png_ptr->mode |= PNG_AT_LAST_IDAT;
+         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
          break;
       }
       if (ret != Z_OK)
-         png_error(png_ptr, "Compression Error");
-
+         png_error(png_ptr, png_ptr->zstream->msg ? png_ptr->zstream->msg :
+                   "Decompression error");
    } while (png_ptr->zstream->avail_out);
 
-   if (ret == Z_STREAM_END)
-      png_ptr->zlib_finished = 1;
-
    png_ptr->row_info.color_type = png_ptr->color_type;
    png_ptr->row_info.width = png_ptr->iwidth;
    png_ptr->row_info.channels = png_ptr->channels;
@@ -381,10 +397,9 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
    png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
       (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
 
-   if (png_ptr->row_buf[0])
-      png_read_filter_row(&(png_ptr->row_info),
-         png_ptr->row_buf + 1, png_ptr->prev_row + 1,
-         (int)(png_ptr->row_buf[0]));
+   png_read_filter_row(png_ptr, &(png_ptr->row_info),
+      png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+      (int)(png_ptr->row_buf[0]));
 
    png_memcpy(png_ptr->prev_row, png_ptr->row_buf, (png_size_t)png_ptr->rowbytes + 1);
 
@@ -471,9 +486,12 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
 /* read the image.  If the image has an alpha channel or a transparency
    chunk, and you have called png_handle_alpha(), you will need to
    initialize the image to the current image that png will be overlaying.
-   Note that png_set_interlace_handling() has no effect on this call.
-   You only need to call this function once.  If you desire to have
-   an image for each pass of a interlaced image, use png_read_rows() */
+   We set the num_rows again here, in case it was incorrectly set in
+   png_read_start_row() by a call to png_read_update_info() or
+   png_start_read_image() if png_set_interlace_handling() wasn't called
+   prior to either of these functions like it should have been.  You only
+   need to call this function once.  If you desire to have an image for
+   each pass of a interlaced image, use png_read_rows() instead */
 void
 png_read_image(png_structp png_ptr, png_bytepp image)
 {
@@ -482,6 +500,9 @@ png_read_image(png_structp png_ptr, png_bytepp image)
    png_bytepp rp;
 
    pass = png_set_interlace_handling(png_ptr);
+
+   png_ptr->num_rows = png_ptr->height; /* Make sure this is set correctly */
+
    for (j = 0; j < pass; j++)
    {
       rp = image;
@@ -518,55 +539,53 @@ png_read_end(png_structp png_ptr, png_infop info)
 
       if (!png_memcmp(chunk_start + 4, png_IHDR, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid IHDR after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_PLTE, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid PLTE after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_gAMA, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid gAMA after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_sBIT, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid sBIT after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_cHRM, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid cHRM after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_tRNS, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid tRNS after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_bKGD, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid bKGD after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_hIST, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid hIST after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_IDAT, 4))
       {
-         if (length > 0 || png_ptr->mode != PNG_AT_LAST_IDAT)
-            png_error(png_ptr, "too many IDAT's found");
+         if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)
+            png_error(png_ptr, "Too many IDAT's found");
       }
       else if (!png_memcmp(chunk_start + 4, png_pHYs, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid pHYs after IDAT");
       }
       else if (!png_memcmp(chunk_start + 4, png_oFFs, 4))
       {
-         png_error(png_ptr, "invalid chunk after IDAT");
+         png_error(png_ptr, "Invalid oFFs after IDAT");
       }
 #if defined(PNG_READ_tIME_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_tIME, 4))
       {
-         if (png_ptr->mode == PNG_BEFORE_IHDR ||
-            png_ptr->mode == PNG_AFTER_IEND)
-            png_error(png_ptr, "Out of Place tIME");
+         png_ptr->mode |= PNG_AFTER_IDAT;
 
          if (info)
             png_handle_tIME(png_ptr, info, length);
@@ -577,9 +596,7 @@ png_read_end(png_structp png_ptr, png_infop info)
 #if defined(PNG_READ_tEXt_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_tEXt, 4))
       {
-         if (png_ptr->mode == PNG_BEFORE_IHDR ||
-            png_ptr->mode == PNG_AFTER_IEND)
-            png_error(png_ptr, "Out of Place tEXt");
+         png_ptr->mode |= PNG_AFTER_IDAT;
 
          if (info)
             png_handle_tEXt(png_ptr, info, length);
@@ -590,9 +607,7 @@ png_read_end(png_structp png_ptr, png_infop info)
 #if defined(PNG_READ_zTXt_SUPPORTED)
       else if (!png_memcmp(chunk_start + 4, png_zTXt, 4))
       {
-         if (png_ptr->mode == PNG_BEFORE_IHDR ||
-            png_ptr->mode == PNG_AFTER_IEND)
-            png_error(png_ptr, "Out of Place zTXt");
+         png_ptr->mode |= PNG_AFTER_IDAT;
 
          if (info)
             png_handle_zTXt(png_ptr, info, length);
@@ -602,31 +617,83 @@ png_read_end(png_structp png_ptr, png_infop info)
 #endif
       else if (!png_memcmp(chunk_start + 4, png_IEND, 4))
       {
-         png_ptr->mode = PNG_AFTER_IEND;
+         png_ptr->mode |= PNG_AFTER_IDAT;
+         png_ptr->mode |= PNG_AFTER_IEND;
       }
       else
       {
-         if ((chunk_start[4] & 0x20) == 0)
-            png_error(png_ptr, "Unknown Critical Chunk");
+         if (chunk_start[4] < 41 || chunk_start[4] > 122  ||
+             (chunk_start[4] > 90 && chunk_start[4] < 97) ||
+             chunk_start[5] < 41 || chunk_start[5] > 122  ||
+             (chunk_start[5] > 90 && chunk_start[5] < 97) ||
+             chunk_start[6] < 41 || chunk_start[6] > 122  ||
+             (chunk_start[6] > 90 && chunk_start[6] < 97) ||
+             chunk_start[7] < 41 || chunk_start[7] > 122  ||
+             (chunk_start[7] > 90 && chunk_start[7] < 97))
+         {
+           png_error(png_ptr, "Invalid chunk type");
+         }
 
+         if ((chunk_start[4] & 0x20) == 0)
+            png_error(png_ptr, "Unknown critical chunk");
+
+         png_ptr->mode |= PNG_AFTER_IDAT;
          png_crc_skip(png_ptr, length);
       }
       png_read_data(png_ptr, chunk_start, 4);
       crc = png_get_uint_32(chunk_start);
-      if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
-         (png_ptr->crc & 0xffffffffL))
+      if (((crc ^ 0xffffffffL) & 0xffffffffL) != (png_ptr->crc & 0xffffffffL))
          png_error(png_ptr, "Bad CRC value");
-      if (png_ptr->mode == PNG_AT_LAST_IDAT)
-         png_ptr->mode = PNG_AFTER_IDAT;
-   } while (png_ptr->mode != PNG_AFTER_IEND);
+   } while (!(png_ptr->mode & PNG_AFTER_IEND));
 }
 
 /* free all memory used by the read */
 void
+png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
+   png_infopp end_info_ptr)
+{
+   png_structp png_ptr = NULL;
+   png_infop info_ptr = NULL, end_info = NULL;
+
+   if (png_ptr_ptr)
+      png_ptr = *png_ptr_ptr;
+
+   if (info_ptr_ptr)
+      info_ptr = *info_ptr_ptr;
+
+   if (end_info_ptr)
+      end_info = *end_info_ptr;
+
+   png_read_destroy(png_ptr, info_ptr, end_info);
+
+   if (info_ptr)
+   {
+      png_destroy_struct((voidp)info_ptr);
+      *info_ptr_ptr = (png_infop)NULL;
+   }
+
+   if (end_info)
+   {
+      png_destroy_struct((voidp)end_info);
+      *end_info_ptr = (png_infop)NULL;
+   }
+
+   if (png_ptr)
+   {
+      png_destroy_struct((voidp)png_ptr);
+      *png_ptr_ptr = (png_structp)NULL;
+   }
+}
+
+/* free all memory used by the read (old) */
+void
 png_read_destroy(png_structp png_ptr, png_infop info, png_infop end_info)
 {
    int i;
    jmp_buf tmp_jmp;
+   png_error_ptr error_fn;
+   png_error_ptr warning_fn;
+   png_voidp error_ptr;
 
    if (info)
    {
@@ -712,8 +779,21 @@ png_read_destroy(png_structp png_ptr, png_infop info, png_infop end_info)
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
    png_large_free(png_ptr, png_ptr->save_buffer);
 #endif
+
+   /* Save the important info out of the png_struct, in case it is
+    * being used again.
+    */
    png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
+
+   error_fn = png_ptr->error_fn;
+   warning_fn = png_ptr->warning_fn;
+   error_ptr = png_ptr->error_ptr;
+
    png_memset(png_ptr, 0, sizeof (png_struct));
+
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
+   png_ptr->error_ptr = error_ptr;
+
    png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
 }
-

pngrio.c

@@ -0,0 +1,141 @@
+
+/* pngrio.c - functions for data input
+
+   libpng 1.0 beta 3 - version 0.89
+   For conditions of distribution and use, see copyright notice in png.h
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
+
+   This file provides a location for all input.  Users which need
+   special handling are expected to write a function which has the same
+   arguments as this, and perform a similar function, but possibly has
+   a different input method.  Note that you shouldn't change this
+   function, but rather write a replacement function and then make
+   libpng use it at run time with png_set_read_fn(...) */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Read the data from whatever input you are using.  The default routine
+   reads from a file pointer.  Note that this routine sometimes gets called
+   with very small lengths, so you should implement some kind of simple
+   buffering if you are using unbuffered reads.  This should never be asked
+   to read more then 64K on a 16 bit machine.  The cast to png_size_t is
+   there to quiet some compilers */
+void
+png_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
+{
+   if (png_ptr->read_data_fn)
+      (*(png_ptr->read_data_fn))(png_ptr, data, length);
+   else
+      png_error(png_ptr, "Call to NULL read function");
+}
+
+/* This is the function which does the actual reading of data.  If you are
+   not reading from a standard C stream, you should create a replacement
+   read_data function and use it at run time with png_set_read_fn(), rather
+   than changing the library. */
+#ifndef USE_FAR_KEYWORD
+static void
+png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
+{
+   png_uint_32 check;
+
+   check = fread(data, 1, (size_t)length, (FILE *)png_ptr->io_ptr);
+   if (check != length)
+   {
+      png_error(png_ptr, "Read Error");
+   }
+}
+#else
+/* this is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+ 
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+ 
+#ifdef _MSC_VER
+/* for FP_OFF */
+#include <dos.h>
+#endif
+ 
+static void
+png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
+{
+   png_uint_32 check;
+   png_byte *n_data;
+
+   /* Check if data really is near. If so, use usual code. */
+#ifdef _MSC_VER
+   /* do it this way just to quiet warning */
+   FP_OFF(n_data) = FP_OFF(data);
+   if (FP_SEG(n_data) == FP_SEG(data))
+#else
+   /* this works in MSC also but with lost segment warning */
+   n_data = (png_byte *)data;
+   if ((png_bytep)n_data == data)
+#endif
+   {
+      check = fread(n_data, 1, (size_t)length, (FILE *)png_ptr->io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t read, remaining, err;
+      check = 0;
+      remaining = (png_size_t)length;
+      do
+      {
+         read = MIN(NEAR_BUF_SIZE, remaining);
+         err = fread(buf, 1, read, (FILE *)png_ptr->io_ptr);
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+         if(err != read)
+            break;
+         else
+            check += err;
+         data += read;
+         remaining -= read;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+   {
+      png_error(png_ptr, "read Error");
+   }
+}
+#endif
+
+/* This function allows the application to supply a new input function
+   for libpng if standard C streams aren't being used.
+
+   This function takes as its arguments:
+   png_ptr      - pointer to a png input data structure
+   io_ptr       - pointer to user supplied structure containing info about
+                  the input functions.  May be NULL.
+   read_data_fn - pointer to a new input function which takes as it's
+                  arguments a pointer to a png_struct, a pointer to
+                  a location where input data can be stored, and a 32-bit
+                  unsigned int which is the number of bytes to be read.
+                  To exit and output any fatal error messages the new write
+                  function should call png_error(png_ptr, "Error msg"). */
+void
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
+   png_rw_ptr read_data_fn)
+{
+   png_ptr->io_ptr = io_ptr;
+
+   if (read_data_fn)
+      png_ptr->read_data_fn = read_data_fn;
+   else
+      png_ptr->read_data_fn = png_default_read_data;
+
+   /* It is an error to write to a read device */
+   png_ptr->write_data_fn = NULL;
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+   png_ptr->output_flush_fn = NULL;
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+}
+

pngrutil.c

@@ -1,10 +1,10 @@
 
 /* pngrutil.c - utilities to read a png file
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
    */
 
 #define PNG_INTERNAL
@@ -30,8 +30,8 @@ png_get_uint_16(png_bytep buf)
 {
    png_uint_16 i;
 
-	i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
-		(png_uint_16)(*(buf + 1)));
+   i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
+      (png_uint_16)(*(buf + 1)));
 
    return i;
 }
@@ -71,6 +71,9 @@ png_handle_IHDR(png_structp png_ptr, png_infop info, png_uint_32 length)
    int bit_depth, color_type, compression_type, filter_type;
    int interlace_type;
 
+   if (png_ptr->mode != PNG_BEFORE_IHDR)
+      png_error(png_ptr, "Out of place IHDR");
+
    /* check the length */
    if (length != 13)
       png_error(png_ptr, "Invalid IHDR chunk");
@@ -87,43 +90,43 @@ png_handle_IHDR(png_structp png_ptr, png_infop info, png_uint_32 length)
 
    /* check for width and height valid values */
    if (width == 0 || height == 0)
-      png_error(png_ptr, "Invalid Width or Height Found");
+      png_error(png_ptr, "Invalid image size in IHDR");
 
    /* check other values */
    if (bit_depth != 1 && bit_depth != 2 &&
       bit_depth != 4 && bit_depth != 8 &&
       bit_depth != 16)
-      png_error(png_ptr, "Invalid Bit Depth Found");
+      png_error(png_ptr, "Invalid bit depth in IHDR");
 
    if (color_type < 0 || color_type == 1 ||
       color_type == 5 || color_type > 6)
-      png_error(png_ptr, "Invalid Color Type Found");
+      png_error(png_ptr, "Invalid color type in IHDR");
 
-	if (color_type == PNG_COLOR_TYPE_PALETTE &&
+   if (color_type == PNG_COLOR_TYPE_PALETTE &&
       bit_depth == 16)
-      png_error(png_ptr, "Found Invalid Color Type and Bit Depth Combination");
+      png_error(png_ptr, "Invalid color type and bit depth combination in IHDR");
 
    if ((color_type == PNG_COLOR_TYPE_RGB ||
       color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
       color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
       bit_depth < 8)
-      png_error(png_ptr, "Found Invalid Color Type and Bit Depth Combination");
+      png_error(png_ptr, "Invalid color type and bit depth in IHDR");
 
    if (interlace_type > 1)
-      png_error(png_ptr, "Found Invalid Interlace Value");
+      png_error(png_ptr, "Invalid interlace method in IHDR");
 
    if (compression_type > 0)
-      png_error(png_ptr, "Found Invalid Compression Value");
+      png_error(png_ptr, "Invalid compression method in IHDR");
 
    if (filter_type > 0)
-      png_error(png_ptr, "Found Invalid Filter Value");
+      png_error(png_ptr, "Invalid filter method in IHDR");
 
    /* set internal variables */
    png_ptr->width = width;
    png_ptr->height = height;
-	png_ptr->bit_depth = (png_byte)bit_depth;
-	png_ptr->interlaced = (png_byte)interlace_type;
-	png_ptr->color_type = (png_byte)color_type;
+   png_ptr->bit_depth = (png_byte)bit_depth;
+   png_ptr->interlaced = (png_byte)interlace_type;
+   png_ptr->color_type = (png_byte)color_type;
 
    /* find number of channels */
    switch (png_ptr->color_type)
@@ -143,13 +146,15 @@ png_handle_IHDR(png_structp png_ptr, png_infop info, png_uint_32 length)
          break;
    }
    /* set up other useful info */
-	png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
-		png_ptr->channels);
+   png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
+      png_ptr->channels);
    png_ptr->rowbytes = ((png_ptr->width *
       (png_uint_32)png_ptr->pixel_depth + 7) >> 3);
    /* call the IHDR callback (which should just set up info) */
    png_read_IHDR(png_ptr, info, width, height, bit_depth,
       color_type, compression_type, filter_type, interlace_type);
+
+   png_ptr->mode |= PNG_HAVE_IHDR;
 }
 
 /* read and check the palette */
@@ -159,13 +164,37 @@ png_handle_PLTE(png_structp png_ptr, png_infop info, png_uint_32 length)
    int num, i;
    png_colorp palette;
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before PLTE");
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      png_error(png_ptr, "Multiple PLTE");
+
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
+   if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+   {
+      png_crc_skip(png_ptr, length);
+      return;
+   }
+#endif
+
    if (length % 3)
-      png_error(png_ptr, "Invalid Palette Chunk");
+   {
+      if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+      {
+         png_warning(png_ptr, "Invalid palette chunk");
+         png_crc_skip(png_ptr, length);
+         return;
+      }
+      else
+      {
+         png_error(png_ptr, "Invalid palette chunk");
+      }
+   }
 
    num = (int)length / 3;
    palette = (png_colorp)png_large_malloc(png_ptr, num * sizeof (png_color));
    png_ptr->do_free |= PNG_FREE_PALETTE;
-	for (i = 0; i < num; i++)
+   for (i = 0; i < num; i++)
    {
       png_byte buf[3];
 
@@ -176,8 +205,10 @@ png_handle_PLTE(png_structp png_ptr, png_infop info, png_uint_32 length)
       palette[i].blue = buf[2];
    }
    png_ptr->palette = palette;
-	png_ptr->num_palette = (png_uint_16)num;
+   png_ptr->num_palette = (png_uint_16)num;
    png_read_PLTE(png_ptr, info, palette, num);
+
+   png_ptr->mode |= PNG_HAVE_PLTE;
 }
 
 #if defined(PNG_READ_gAMA_SUPPORTED)
@@ -188,10 +219,16 @@ png_handle_gAMA(png_structp png_ptr, png_infop info, png_uint_32 length)
    float gamma;
    png_byte buf[4];
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before gAMA");
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Out of place gAMA chunk");
+
    if (length != 4)
    {
       png_warning(png_ptr, "Incorrect gAMA chunk length");
-		png_crc_skip(png_ptr, length);
+      png_crc_skip(png_ptr, length);
       return;
    }
 
@@ -199,7 +236,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info, png_uint_32 length)
    igamma = png_get_uint_32(buf);
    /* check for zero gamma */
    if (!igamma)
-		return;
+      return;
 
    gamma = (float)igamma / (float)100000.0;
    png_read_gAMA(png_ptr, info, gamma);
@@ -212,20 +249,26 @@ void
 png_handle_sBIT(png_structp png_ptr, png_infop info, png_uint_32 length)
 {
    int slen;
-	png_byte buf[4];
+   png_byte buf[4];
 
    buf[0] = buf[1] = buf[2] = buf[3] = 0;
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before sBIT");
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Out of place sBIT chunk");
+
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       slen = 3;
    else
-		slen = png_ptr->channels;
+      slen = png_ptr->channels;
 
    if (length != (png_uint_32)slen)
    {
       png_warning(png_ptr, "Incorrect sBIT chunk length");
-		png_crc_skip(png_ptr, length);
-		return;
+      png_crc_skip(png_ptr, length);
+      return;
    }
 
    png_crc_read(png_ptr, buf, length);
@@ -238,7 +281,7 @@ png_handle_sBIT(png_structp png_ptr, png_infop info, png_uint_32 length)
    }
    else
    {
-		png_ptr->sig_bit.gray = buf[0];
+      png_ptr->sig_bit.gray = buf[0];
       png_ptr->sig_bit.alpha = buf[1];
    }
    png_read_sBIT(png_ptr, info, &(png_ptr->sig_bit));
@@ -253,11 +296,17 @@ png_handle_cHRM(png_structp png_ptr, png_infop info, png_uint_32 length)
    png_uint_32 v;
    float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before sBIT");
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Missing PLTE before cHRM");
+
    if (length != 32)
    {
       png_warning(png_ptr, "Incorrect cHRM chunk length");
-		png_crc_skip(png_ptr, length);
-		return;
+      png_crc_skip(png_ptr, length);
+      return;
    }
 
    png_crc_read(png_ptr, buf, 4);
@@ -293,7 +342,7 @@ png_handle_cHRM(png_structp png_ptr, png_infop info, png_uint_32 length)
    blue_y = (float)v / (float)100000.0;
 
    png_read_cHRM(png_ptr, info,
-		white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
 }
 #endif
 
@@ -301,19 +350,27 @@ png_handle_cHRM(png_structp png_ptr, png_infop info, png_uint_32 length)
 void
 png_handle_tRNS(png_structp png_ptr, png_infop info, png_uint_32 length)
 {
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before tRNS");
+
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    {
-      if (length > png_ptr->num_palette)
+      if (!(png_ptr->mode & PNG_HAVE_PLTE))
+      {
+         /* Should be an error, but we can cope with it */
+         png_warning(png_ptr, "Missing PLTE before tRNS");
+      }
+      else if (length > png_ptr->num_palette)
       {
          png_warning(png_ptr, "Incorrect tRNS chunk length");
-			png_crc_skip(png_ptr, length);
+         png_crc_skip(png_ptr, length);
          return;
       }
 
       png_ptr->trans = (png_bytep)png_large_malloc(png_ptr, length);
       png_ptr->do_free |= PNG_FREE_TRANS;
-		png_crc_read(png_ptr, png_ptr->trans, length);
-		png_ptr->num_trans = (png_uint_16)length;
+      png_crc_read(png_ptr, png_ptr->trans, length);
+      png_ptr->num_trans = (png_uint_16)length;
    }
    else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
    {
@@ -322,7 +379,7 @@ png_handle_tRNS(png_structp png_ptr, png_infop info, png_uint_32 length)
       if (length != 6)
       {
          png_warning(png_ptr, "Incorrect tRNS chunk length");
-			png_crc_skip(png_ptr, length);
+         png_crc_skip(png_ptr, length);
          return;
       }
 
@@ -339,16 +396,20 @@ png_handle_tRNS(png_structp png_ptr, png_infop info, png_uint_32 length)
       if (length != 2)
       {
          png_warning(png_ptr, "Incorrect tRNS chunk length");
-			png_crc_skip(png_ptr, length);
-			return;
-		}
+         png_crc_skip(png_ptr, length);
+         return;
+      }
 
-		png_crc_read(png_ptr, buf, 2);
-		png_ptr->num_trans = 1;
-		png_ptr->trans_values.gray = png_get_uint_16(buf);
-	}
-	else
-      png_warning(png_ptr, "Invalid tRNS chunk");
+      png_crc_read(png_ptr, buf, 2);
+      png_ptr->num_trans = 1;
+      png_ptr->trans_values.gray = png_get_uint_16(buf);
+   }
+   else
+   {
+      png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
+      png_crc_skip(png_ptr, length);
+      return;
+   }
 
    png_read_tRNS(png_ptr, info, png_ptr->trans, png_ptr->num_trans,
       &(png_ptr->trans_values));
@@ -362,6 +423,16 @@ png_handle_bKGD(png_structp png_ptr, png_infop info, png_uint_32 length)
    int truelen;
    png_byte buf[6];
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before bKGD");
+   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+            !(png_ptr->mode & PNG_HAVE_PLTE))
+   {
+      png_warning(png_ptr, "Missing PLTE before bKGD");
+      png_crc_skip(png_ptr, length);
+      return;
+   }
+
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       truelen = 1;
    else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
@@ -371,16 +442,30 @@ png_handle_bKGD(png_structp png_ptr, png_infop info, png_uint_32 length)
 
    if (length != (png_uint_32)truelen)
    {
-		png_warning(png_ptr, "Incorrect bKGD chunk length");
-		png_crc_skip(png_ptr, length);
+      png_warning(png_ptr, "Incorrect bKGD chunk length");
+      png_crc_skip(png_ptr, length);
       return;
    }
 
    png_crc_read(png_ptr, buf, length);
+   /* We convert the index value into RGB components so that we can allow
+    * arbitrary RGB values for background when we have transparency, and
+    * so it is easy to determine the RGB values of the background color
+    * from the info_ptr. */
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
       png_ptr->background.index = buf[0];
+      png_ptr->background.red = (png_uint_16)png_ptr->palette[buf[0]].red;
+      png_ptr->background.green = (png_uint_16)png_ptr->palette[buf[0]].green;
+      png_ptr->background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue;
+   }
    else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
+   {
+      png_ptr->background.red =
+      png_ptr->background.green =
+      png_ptr->background.blue =
       png_ptr->background.gray = png_get_uint_16(buf);
+   }
    else
    {
       png_ptr->background.red = png_get_uint_16(buf);
@@ -396,20 +481,29 @@ png_handle_bKGD(png_structp png_ptr, png_infop info, png_uint_32 length)
 void
 png_handle_hIST(png_structp png_ptr, png_infop info, png_uint_32 length)
 {
-	int num, i;
+   int num, i;
 
-	if (length != 2 * png_ptr->num_palette)
-	{
-		png_warning(png_ptr, "Incorrect hIST chunk length");
-		png_crc_skip(png_ptr, length);
-		return;
-	}
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before hIST");
+   else if (!(png_ptr->mode & PNG_HAVE_PLTE))
+   {
+      png_warning(png_ptr, "Missing PLTE before hIST");
+      png_crc_skip(png_ptr, length);
+      return;
+   }
+
+   if (length != 2 * png_ptr->num_palette)
+   {
+      png_warning(png_ptr, "Incorrect hIST chunk length");
+      png_crc_skip(png_ptr, length);
+      return;
+   }
 
    num = (int)length / 2;
-	png_ptr->hist = (png_uint_16p)png_large_malloc(png_ptr,
-		num * sizeof (png_uint_16));
+   png_ptr->hist = (png_uint_16p)png_large_malloc(png_ptr,
+      num * sizeof (png_uint_16));
    png_ptr->do_free |= PNG_FREE_HIST;
-	for (i = 0; i < num; i++)
+   for (i = 0; i < num; i++)
    {
       png_byte buf[2];
 
@@ -428,12 +522,15 @@ png_handle_pHYs(png_structp png_ptr, png_infop info, png_uint_32 length)
    png_uint_32 res_x, res_y;
    int unit_type;
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before pHYS");
+
    if (length != 9)
    {
-		png_warning(png_ptr, "Incorrect pHYs chunk length");
-		png_crc_skip(png_ptr, length);
+      png_warning(png_ptr, "Incorrect pHYs chunk length");
+      png_crc_skip(png_ptr, length);
       return;
-	}
+   }
 
    png_crc_read(png_ptr, buf, 9);
 
@@ -452,14 +549,17 @@ png_handle_oFFs(png_structp png_ptr, png_infop info, png_uint_32 length)
    png_uint_32 offset_x, offset_y;
    int unit_type;
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before oFFs");
+
    if (length != 9)
    {
-		png_warning(png_ptr, "Incorrect oFFs chunk length");
-		png_crc_skip(png_ptr, length);
+      png_warning(png_ptr, "Incorrect oFFs chunk length");
+      png_crc_skip(png_ptr, length);
       return;
    }
 
-	png_crc_read(png_ptr, buf, 9);
+   png_crc_read(png_ptr, buf, 9);
 
    offset_x = png_get_uint_32(buf);
    offset_y = png_get_uint_32(buf + 4);
@@ -475,10 +575,13 @@ png_handle_tIME(png_structp png_ptr, png_infop info, png_uint_32 length)
    png_byte buf[7];
    png_time mod_time;
 
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before tIME");
+
    if (length != 7)
    {
-		png_warning(png_ptr, "Incorrect tIME chunk length");
-		png_crc_skip(png_ptr, length);
+      png_warning(png_ptr, "Incorrect tIME chunk length");
+      png_crc_skip(png_ptr, length);
       return;
    }
 
@@ -489,7 +592,7 @@ png_handle_tIME(png_structp png_ptr, png_infop info, png_uint_32 length)
    mod_time.hour = buf[4];
    mod_time.day = buf[3];
    mod_time.month = buf[2];
-	mod_time.year = png_get_uint_16(buf);
+   mod_time.year = png_get_uint_16(buf);
 
    png_read_tIME(png_ptr, info, &mod_time);
 }
@@ -500,15 +603,18 @@ png_handle_tIME(png_structp png_ptr, png_infop info, png_uint_32 length)
 void
 png_handle_tEXt(png_structp png_ptr, png_infop info, png_uint_32 length)
 {
-	png_charp key;
+   png_charp key;
    png_charp text;
 
-	key = (png_charp )png_large_malloc(png_ptr, length + 1);
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before tEXt");
+
+   key = (png_charp )png_large_malloc(png_ptr, length + 1);
    png_crc_read(png_ptr, (png_bytep )key, length);
-	key[(png_size_t)length] = '\0';
+   key[(png_size_t)length] = '\0';
 
    for (text = key; *text; text++)
-      /* empty loop */ ;
+      /* empty loop to check key length */ ;
 
    if (text != key + (png_size_t)length)
       text++;
@@ -518,17 +624,21 @@ png_handle_tEXt(png_structp png_ptr, png_infop info, png_uint_32 length)
 #endif
 
 #if defined(PNG_READ_zTXt_SUPPORTED)
-/* note: this does not correctly handle chunks that are > 64K compressed */
+/* note: this does not correctly handle chunks that are > 64K compressed
+   on those systems that can't malloc more than 64KB at a time. */
 void
 png_handle_zTXt(png_structp png_ptr, png_infop info, png_uint_32 length)
 {
+   static char msg[] = "Error decoding zTXt chunk";
    png_charp key;
    png_charp text;
-   int ret;
    png_uint_32 text_size, key_size;
 
-	key = png_large_malloc(png_ptr, length + 1);
-	png_crc_read(png_ptr, (png_bytep )key, length);
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before zTXt");
+
+   key = png_large_malloc(png_ptr, length + 1);
+   png_crc_read(png_ptr, (png_bytep )key, length);
    key[(png_size_t)length] = '\0';
 
    for (text = key; *text; text++)
@@ -538,103 +648,108 @@ png_handle_zTXt(png_structp png_ptr, png_infop info, png_uint_32 length)
    if (text == key + (png_size_t)length)
    {
       png_warning(png_ptr, "Zero length zTXt chunk");
-		png_large_free(png_ptr, key);
-      return;
+      text_size = 0;
    }
-
-   text++;
-
-   if (*text) /* check compression byte */
+   else if (*(++text)) /* check compression type byte */
    {
+      png_warning(png_ptr, "Unknown zTXt compression type");
+
+      /* Copy what we can of the error message into the text chunk */
+      text_size = length - (text - key) - 1;
+      text_size = sizeof(msg) > text_size ? text_size : sizeof(msg);
+      png_memcpy(text, msg, (png_size_t)(text_size + 1));
+   }
+   else
+   {
+      text++;
+
+      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_size_t)png_ptr->zbuf_size;
+
+      key_size = text - key;
+      text_size = 0;
+      text = NULL;
+
+      while (png_ptr->zstream->avail_in)
+      {
+         int ret;
+
+         ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
+         if (ret != Z_OK && ret != Z_STREAM_END)
+         {
+            if (png_ptr->zstream->msg)
+               png_warning(png_ptr, png_ptr->zstream->msg);
+            else
+               png_warning(png_ptr, "zTXt decompression error");
+            inflateReset(png_ptr->zstream);
+            png_ptr->zstream->avail_in = 0;
+
+            if (!text)
+            {
+               text_size = key_size + sizeof(msg) + 1;
+               text = (png_charp)png_large_malloc(png_ptr, text_size);
+               png_memcpy(text, key, (png_size_t)key_size);
+            }
+
+            text[text_size - 1] = '\0';
+
+            /* Copy what we can of the error message into the text chunk */
+            text_size = length - (text - key) - 1;
+            text_size = sizeof(msg) > text_size ? text_size : sizeof(msg);
+            png_memcpy(text + key_size, msg, (png_size_t)(text_size + 1));
+            break;
+         }
+         if (!png_ptr->zstream->avail_out || ret == Z_STREAM_END)
+         {
+            if (!text)
+            {
+               text = (png_charp)png_large_malloc(png_ptr,
+                  png_ptr->zbuf_size - png_ptr->zstream->avail_out +
+                     key_size + 1);
+               png_memcpy(text + (png_size_t)key_size, png_ptr->zbuf,
+                  (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
+               png_memcpy(text, key, (png_size_t)key_size);
+               text_size = key_size + (png_size_t)png_ptr->zbuf_size -
+                  png_ptr->zstream->avail_out;
+               *(text + (png_size_t)text_size) = '\0';
+            }
+            else
+            {
+               png_charp tmp;
+
+               tmp = text;
+               text = png_large_malloc(png_ptr, text_size +
+                  png_ptr->zbuf_size - png_ptr->zstream->avail_out + 1);
+               png_memcpy(text, tmp, (png_size_t)text_size);
+               png_large_free(png_ptr, tmp);
+               png_memcpy(text + (png_size_t)text_size, png_ptr->zbuf,
+                  (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
+               text_size += png_ptr->zbuf_size - png_ptr->zstream->avail_out;
+               *(text + (png_size_t)text_size) = '\0';
+            }
+            if (ret != Z_STREAM_END)
+            {
+               png_ptr->zstream->next_out = png_ptr->zbuf;
+               png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
+            }
+            else
+            {
+               break;
+            }
+         }
+      }
+
+      inflateReset(png_ptr->zstream);
+      png_ptr->zstream->avail_in = 0;
+
       png_large_free(png_ptr, key);
-      return;
+      key = text;
+      text += (png_size_t)key_size;
+      text_size -= key_size;
    }
 
-   text++;
-
-   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_size_t)png_ptr->zbuf_size;
-
-   key_size = text - key;
-   text_size = 0;
-	text = NULL;
-   ret = Z_STREAM_END;
-
-   while (png_ptr->zstream->avail_in)
-   {
-		ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
-      if (ret != Z_OK && ret != Z_STREAM_END)
-      {
-			if (png_ptr->zstream->msg)
-				png_warning(png_ptr, png_ptr->zstream->msg);
-         else
-				png_warning(png_ptr, "zTXt decompression error");
-			inflateReset(png_ptr->zstream);
-         png_ptr->zstream->avail_in = 0;
-         png_large_free(png_ptr, key);
-         png_large_free(png_ptr, text);
-         return;
-      }
-      if (!png_ptr->zstream->avail_out || ret == Z_STREAM_END)
-      {
-         if (!text)
-         {
-            text = (png_charp)png_large_malloc(png_ptr,
-               png_ptr->zbuf_size - png_ptr->zstream->avail_out +
-                  key_size + 1);
-            png_memcpy(text + (png_size_t)key_size, png_ptr->zbuf,
-               (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
-            png_memcpy(text, key, (png_size_t)key_size);
-            text_size = key_size + (png_size_t)png_ptr->zbuf_size -
-               png_ptr->zstream->avail_out;
-            *(text + (png_size_t)text_size) = '\0';
-         }
-         else
-         {
-				png_charp tmp;
-
-            tmp = text;
-            text = png_large_malloc(png_ptr, text_size +
-               png_ptr->zbuf_size - png_ptr->zstream->avail_out + 1);
-            png_memcpy(text, tmp, (png_size_t)text_size);
-            png_large_free(png_ptr, tmp);
-            png_memcpy(text + (png_size_t)text_size, png_ptr->zbuf,
-               (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
-            text_size += png_ptr->zbuf_size - png_ptr->zstream->avail_out;
-            *(text + (png_size_t)text_size) = '\0';
-         }
-         if (ret != Z_STREAM_END)
-         {
-            png_ptr->zstream->next_out = png_ptr->zbuf;
-            png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
-         }
-      }
-      else
-      {
-         break;
-      }
-
-      if (ret == Z_STREAM_END)
-         break;
-   }
-
-	inflateReset(png_ptr->zstream);
-   png_ptr->zstream->avail_in = 0;
-
-   if (ret != Z_STREAM_END)
-   {
-      png_large_free(png_ptr, key);
-      png_large_free(png_ptr, text);
-      return;
-   }
-
-   png_large_free(png_ptr, key);
-   key = text;
-   text += (png_size_t)key_size;
-   text_size -= key_size;
-
    png_read_zTXt(png_ptr, info, key, text, text_size, 0);
 }
 #endif
@@ -683,7 +798,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
                {
                   value = (*sp >> shift) & 0x1;
                   *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
-						*dp |= (png_byte)(value << shift);
+                  *dp |= (png_byte)(value << shift);
                }
 
                if (shift == 0)
@@ -721,7 +836,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
                {
                   value = (*sp >> shift) & 0x3;
                   *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
-						*dp |= (png_byte)(value << shift);
+                  *dp |= (png_byte)(value << shift);
                }
 
                if (shift == 0)
@@ -758,7 +873,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
                {
                   value = (*sp >> shift) & 0xf;
                   *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
-						*dp |= (png_byte)(value << shift);
+                  *dp |= (png_byte)(value << shift);
                }
 
                if (shift == 0)
@@ -835,7 +950,7 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass)
             dshift = 7 - (int)((final_width + 7) & 7);
             for (i = row_info->width; i; i--)
             {
-					v = (png_byte)((*sp >> sshift) & 0x1);
+               v = (png_byte)((*sp >> sshift) & 0x1);
                for (j = 0; j < png_pass_inc[pass]; j++)
                {
                   *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
@@ -871,11 +986,11 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass)
             dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);
             for (i = row_info->width; i; i--)
             {
-					v = (png_byte)((*sp >> sshift) & 0x3);
+               v = (png_byte)((*sp >> sshift) & 0x3);
                for (j = 0; j < png_pass_inc[pass]; j++)
                {
                   *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
-						*dp |= (png_byte)(v << dshift);
+                  *dp |= (png_byte)(v << dshift);
                   if (dshift == 6)
                   {
                      dshift = 0;
@@ -908,7 +1023,7 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass)
             dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);
             for (i = row_info->width; i; i--)
             {
-					v = (png_byte)((*sp >> sshift) & 0xf);
+               v = (png_byte)((*sp >> sshift) & 0xf);
                for (j = 0; j < png_pass_inc[pass]; j++)
                {
                   *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
@@ -964,7 +1079,7 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass)
 #endif
 
 void
-png_read_filter_row(png_row_infop row_info, png_bytep row,
+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
    png_bytep prev_row, int filter)
 {
    switch (filter)
@@ -1064,6 +1179,7 @@ png_read_filter_row(png_row_infop row_info, png_bytep row,
          break;
       }
       default:
+         png_error(png_ptr, "Bad adaptive filter type");
          break;
    }
 }
@@ -1107,7 +1223,7 @@ png_read_finish_row(png_structp png_ptr)
          return;
    }
 
-   if (!png_ptr->zlib_finished)
+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
    {
       char extra;
       int ret;
@@ -1127,7 +1243,7 @@ png_read_finish_row(png_structp png_ptr)
                crc = png_get_uint_32(buf);
                if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
                   (png_ptr->crc & 0xffffffffL))
-                  png_error(png_ptr, "Bad CRC value");
+                  png_warning(png_ptr, "Bad CRC value");
 
                png_read_data(png_ptr, buf, 4);
                png_ptr->idat_size = png_get_uint_32(buf);
@@ -1145,17 +1261,18 @@ png_read_finish_row(png_structp png_ptr)
             png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream->avail_in);
             png_ptr->idat_size -= png_ptr->zstream->avail_in;
          }
-			ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
+         ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
          if (ret == Z_STREAM_END)
          {
             if (!(png_ptr->zstream->avail_out) || png_ptr->zstream->avail_in ||
                png_ptr->idat_size)
                png_error(png_ptr, "Extra compressed data");
-            png_ptr->mode = PNG_AT_LAST_IDAT;
+            png_ptr->mode |= PNG_AT_LAST_IDAT;
             break;
          }
          if (ret != Z_OK)
-            png_error(png_ptr, "Compression Error");
+            png_error(png_ptr, png_ptr->zstream->msg ? png_ptr->zstream->msg :
+                      "Decompression Error");
 
          if (!(png_ptr->zstream->avail_out))
             png_error(png_ptr, "Extra compressed data");
@@ -1169,7 +1286,7 @@ png_read_finish_row(png_structp png_ptr)
 
    inflateReset(png_ptr->zstream);
 
-   png_ptr->mode = PNG_AT_LAST_IDAT;
+   png_ptr->mode |= PNG_AT_LAST_IDAT;
 }
 
 void
@@ -1206,13 +1323,11 @@ png_read_start_row(png_structp png_ptr)
 
 #if defined(PNG_READ_PACK_SUPPORTED)
    if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
-   {
       max_pixel_depth = 8;
-   }
 #endif
 
-#if defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_PACK_SUPPORTED)
-   if (png_ptr->transformations & (PNG_EXPAND | PNG_PACK))
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+   if (png_ptr->transformations & PNG_EXPAND)
    {
       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
@@ -1277,19 +1392,18 @@ png_read_start_row(png_structp png_ptr)
       1 + ((max_pixel_depth + 7) >> 3);
 #ifdef PNG_MAX_MALLOC_64K
    if (rowbytes > 65536L)
-      png_error(png_ptr, "This image requires a row greater then 64KB");
+      png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
-	png_ptr->row_buf = (png_bytep )png_large_malloc(png_ptr, rowbytes);
+   png_ptr->row_buf = (png_bytep )png_large_malloc(png_ptr, rowbytes);
 
 #ifdef PNG_MAX_MALLOC_64K
    if (png_ptr->rowbytes + 1 > 65536L)
-		png_error(png_ptr, "This image requires a row greater then 64KB");
+      png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
-   png_ptr->prev_row = png_large_malloc(png_ptr,
-      png_ptr->rowbytes + 1);
+   png_ptr->prev_row = png_large_malloc(png_ptr, png_ptr->rowbytes + 1);
 
    png_memset(png_ptr->prev_row, 0, (png_size_t)png_ptr->rowbytes + 1);
 
-   png_ptr->row_init = 1;
+   png_ptr->flags |= PNG_FLAG_ROW_INIT;
 }
 

pngtest.c

@@ -1,9 +1,9 @@
 /* pngtest.c - a simple test program to test libpng
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
 */
 
 #include <stdio.h>
@@ -16,30 +16,34 @@
 
 /* defined so I can write to a file on gui/windowing platforms */
 /*  #define STDERR stderr  */
-#define STDERR stdout	/* for DOS */
+#define STDERR stdout   /* for DOS */
 
 /* input and output filenames */
-char inname[] = "pngtest.png";
-char outname[] = "pngout.png";
-
-png_struct read_ptr;
-png_struct write_ptr;
-png_info info_ptr;
-png_info end_info;
+#ifdef RISCOS
+char *inname = "pngtest_pn";
+char *outname = "pngout_png";
+#else
+char *inname = "pngtest.png";
+char *outname = "pngout.png";
+#endif
 
 char inbuf[256], outbuf[256];
 
-int main()
+int main(int argc, char *argv[])
 {
    FILE *fpin, *fpout;
-	png_bytep row_buf;
-   png_byte * near_row_buf;
+   png_structp read_ptr;
+   png_structp write_ptr;
+   png_infop info_ptr;
+   png_infop end_info;
+   png_bytep row_buf;
+   png_byte *near_row_buf;
    png_uint_32 rowbytes;
    png_uint_32 y;
    int channels, num_pass, pass;
 
-	row_buf = (png_bytep)0;
-   near_row_buf = (png_byte *)0;
+   row_buf = (png_bytep)NULL;
+   near_row_buf = (png_byte *)NULL;
 
    fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
 
@@ -51,6 +55,18 @@ int main()
       fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);
    }
 
+   if (argc > 1)
+     inname = argv[1];
+
+   if (argc > 2)
+     outname = argv[2];
+
+   if (argc > 3)
+   {
+     fprintf(stderr, "usage: %s [infile.png] [outfile.png]\n", argv[0]);
+     exit(1);
+   }
+
    fpin = fopen(inname, "rb");
    if (!fpin)
    {
@@ -61,62 +77,68 @@ int main()
    fpout = fopen(outname, "wb");
    if (!fpout)
    {
-      fprintf(STDERR, "could not open output file %s\n", outname);
+      fprintf(STDERR, "Could not open output file %s\n", outname);
       fclose(fpin);
       return 1;
    }
 
-   if (setjmp(read_ptr.jmpbuf))
+   read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (void *)NULL,
+      (png_error_ptr)NULL,  (png_error_ptr)NULL);
+   write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (void *)NULL,
+      (png_error_ptr)NULL, (png_error_ptr)NULL);
+   info_ptr = png_create_info_struct(read_ptr);
+   end_info = png_create_info_struct(read_ptr);
+
+   if (setjmp(read_ptr->jmpbuf))
    {
       fprintf(STDERR, "libpng read error\n");
+      png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
+      png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
       fclose(fpin);
       fclose(fpout);
       return 1;
    }
 
-   if (setjmp(write_ptr.jmpbuf))
-	{
+   if (setjmp(write_ptr->jmpbuf))
+   {
       fprintf(STDERR, "libpng write error\n");
+      png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
+      png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
       fclose(fpin);
       fclose(fpout);
       return 1;
    }
 
-   png_read_init(&read_ptr);
-   png_write_init(&write_ptr);
-   png_info_init(&info_ptr);
-   png_info_init(&end_info);
+   png_init_io(read_ptr, fpin);
+   png_init_io(write_ptr, fpout);
 
-   png_init_io(&read_ptr, fpin);
-   png_init_io(&write_ptr, fpout);
+   png_read_info(read_ptr, info_ptr);
+   png_write_info(write_ptr, info_ptr);
 
-   png_read_info(&read_ptr, &info_ptr);
-   png_write_info(&write_ptr, &info_ptr);
-
-	if ((info_ptr.color_type & 3) == 2)
-      channels = 3;
-   else
+   if ((info_ptr->color_type & PNG_COLOR_TYPE_PALETTE)==PNG_COLOR_TYPE_PALETTE)
       channels = 1;
-   if (info_ptr.color_type & 4)
+   else
+      channels = 3;
+   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
       channels++;
 
-   rowbytes = ((info_ptr.width * info_ptr.bit_depth * channels + 7) >> 3);
-	near_row_buf = (png_byte *)malloc((size_t)rowbytes);
+   rowbytes = ((info_ptr->width * info_ptr->bit_depth * channels + 7) >> 3);
+   near_row_buf = (png_byte *)malloc((size_t)rowbytes);
    row_buf = (png_bytep)near_row_buf;
    if (!row_buf)
    {
-      fprintf(STDERR, "no memory to allocate row buffer\n");
-      png_read_destroy(&read_ptr, &info_ptr, (png_infop )0);
-      png_write_destroy(&write_ptr);
+      fprintf(STDERR, "No memory to allocate row buffer\n");
+      png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
+      png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
       fclose(fpin);
       fclose(fpout);
       return 1;
    }
 
-   if (info_ptr.interlace_type)
+   if (info_ptr->interlace_type)
    {
-      num_pass = png_set_interlace_handling(&read_ptr);
-      num_pass = png_set_interlace_handling(&write_ptr);
+      num_pass = png_set_interlace_handling(read_ptr);
+      num_pass = png_set_interlace_handling(write_ptr);
    }
    else
    {
@@ -125,21 +147,21 @@ int main()
 
    for (pass = 0; pass < num_pass; pass++)
    {
-      for (y = 0; y < info_ptr.height; y++)
+      for (y = 0; y < info_ptr->height; y++)
       {
 #ifdef TESTING
          fprintf(STDERR, "Processing line #%ld\n", y);
 #endif
-			png_read_rows(&read_ptr, (png_bytepp)&row_buf, (png_bytepp)0, 1);
-			png_write_rows(&write_ptr, (png_bytepp)&row_buf, 1);
+         png_read_rows(read_ptr, (png_bytepp)&row_buf, (png_bytepp)0, 1);
+         png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
       }
    }
 
-   png_read_end(&read_ptr, &end_info);
-   png_write_end(&write_ptr, &end_info);
+   png_read_end(read_ptr, end_info);
+   png_write_end(write_ptr, end_info);
 
-   png_read_destroy(&read_ptr, &info_ptr, &end_info);
-   png_write_destroy(&write_ptr);
+   png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
+   png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
 
    fclose(fpin);
    fclose(fpout);
@@ -150,14 +172,14 @@ int main()
 
    if (!fpin)
    {
-      fprintf(STDERR, "could not find file %s\n", inname);
+      fprintf(STDERR, "Could not find file %s\n", inname);
       return 1;
    }
 
    fpout = fopen(outname, "rb");
    if (!fpout)
    {
-      fprintf(STDERR, "could not find file %s\n", outname);
+      fprintf(STDERR, "Could not find file %s\n", outname);
       fclose(fpin);
       return 1;
    }
@@ -171,7 +193,8 @@ int main()
 
       if (num_in != num_out)
       {
-         fprintf(STDERR, "files are of a different size\n");
+         fprintf(STDERR, "Files %s and %s are of a different size\n",
+                 inname, outname);
          fclose(fpin);
          fclose(fpout);
          return 1;
@@ -182,7 +205,7 @@ int main()
 
       if (memcmp(inbuf, outbuf, num_in))
       {
-         fprintf(STDERR, "files are different\n");
+         fprintf(STDERR, "Files %s and %s are different\n", inname, outname);
          fclose(fpin);
          fclose(fpout);
          return 1;

pngtodo.txt

@@ -3,14 +3,14 @@ pngtodo.txt - list of things to do for libpng
 for 0.9
    improved dithering
    final bug fixes
-	cHRM transformation
+   cHRM transformation
    better documentation
 
 after 1.0
    overlaying one image on top of another
-	optional palette creation
-	histogram creation
-	text conversion between different code types
+   optional palette creation
+   histogram creation
+   text conversion between different code types
    support for other chunks being defined (sCAl, the gIF series,
       and others that people come up with).
    pull writer

pngtrans.c

@@ -2,10 +2,10 @@
 /* pngtrans.c - transforms the data in a row
    routines used by both readers and writers
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
    */
 
 #define PNG_INTERNAL
@@ -72,7 +72,11 @@ png_set_filler(png_structp png_ptr, int filler, int filler_loc)
 {
    png_ptr->transformations |= PNG_FILLER;
    png_ptr->filler = (png_byte)filler;
-   png_ptr->filler_loc = (png_byte)filler_loc;
+   if (filler_loc == PNG_FILLER_AFTER)
+      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
+   else
+      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
+
    if (png_ptr->color_type == PNG_COLOR_TYPE_RGB &&
       png_ptr->bit_depth == 8)
       png_ptr->usr_channels = 4;
@@ -199,7 +203,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
       }
       else if (row_info->color_type == 6 && row_info->bit_depth == 16)
       {
-			png_bytep rp;
+         png_bytep rp;
          png_byte t[2];
          png_uint_32 i;
 

pngwio.c

@@ -0,0 +1,174 @@
+
+/* pngwio.c - functions for data output
+
+   libpng 1.0 beta 3 - version 0.89
+   For conditions of distribution and use, see copyright notice in png.h
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
+
+   This file provides a location for all output.  Users which need
+   special handling are expected to write functions which have the same
+   arguments as these, and perform similar functions, but possibly use
+   different output methods.  Note that you shouldn't change these
+   functions, but rather write replacement functions and then change
+   them at run time with png_set_write_fn(...) */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Write the data to whatever output you are using.  The default routine
+   writes to a file pointer.  Note that this routine sometimes gets called
+   with very small lengths, so you should implement some kind of simple
+   buffering if you are using unbuffered writes.  This should never be asked
+   to write more then 64K on a 16 bit machine.  The cast to png_size_t is
+   there to quiet warnings of certain compilers. */
+
+void
+png_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
+{
+   if (png_ptr->write_data_fn)
+      (*(png_ptr->write_data_fn))(png_ptr, data, length);
+   else
+      png_error(png_ptr, "Call to NULL write function");
+}
+
+/* This is the function which does the actual writing of data.  If you are
+   not writing to a standard C stream, you should create a replacement
+   write_data function and use it at run time with png_set_write_fn(), rather
+   than changing the library. */
+#ifndef USE_FAR_KEYWORD
+static void
+png_default_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
+{
+   png_uint_32 check;
+
+   check = fwrite(data, 1, (png_size_t)length, (FILE *)(png_ptr->io_ptr));
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+#else
+/* this is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+#ifdef _MSC_VER
+/* for FP_OFF */
+#include <dos.h>
+#endif
+
+static void
+png_default_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
+{
+   png_uint_32 check;
+   png_byte *n_data;
+
+   /* Check if data really is near. If so, use usual code. */
+#ifdef _MSC_VER
+   /* do it this way just to quiet warning */
+   FP_OFF(n_data) = FP_OFF(data);
+   if (FP_SEG(n_data) == FP_SEG(data))
+#else
+   /* this works in MSC also but with lost segment warning */
+   n_data = (png_byte *)data;
+   if ((png_bytep)n_data == data)
+#endif
+   {
+      check = fwrite(n_data, 1, (png_size_t)length, (FILE *)(png_ptr->io_ptr));
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t written, remaining, err;
+      check = 0;
+      remaining = (png_size_t)length;
+      do
+      {
+         written = MIN(NEAR_BUF_SIZE, remaining);
+         png_memcpy(buf, data, written); /* copy far buffer to near buffer */
+         err = fwrite(buf, 1, written, (FILE *)(png_ptr->io_ptr));
+         if (err != written)
+            break;
+         else
+            check += err;
+         data += written;
+         remaining -= written;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+
+#endif
+
+/* This function is called to output any data pending writing (normally
+   to disk).  After png_flush is called, there should be no data pending
+   writing in any buffers. */
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+void
+png_flush(png_structp png_ptr)
+{
+   if (png_ptr->output_flush_fn)
+      (*(png_ptr->output_flush_fn))(png_ptr);
+}
+
+static void
+png_default_flush(png_structp png_ptr)
+{
+   if ((FILE *)(png_ptr->io_ptr))
+      fflush((FILE *)(png_ptr->io_ptr));
+}
+#endif
+
+/* This function allows the application to supply new output functions for
+   libpng if standard C streams aren't being used.
+
+   This function takes as its arguments:
+   png_ptr       - pointer to a png output data structure
+   io_ptr        - pointer to user supplied structure containing info about
+                   the output functions.  May be NULL.
+   write_data_fn - pointer to a new output function which takes as its
+                   arguments a pointer to a png_struct, a pointer to
+                   data to be written, and a 32-bit unsigned int which is
+                   the number of bytes to be written.  The new write
+                   function should call png_error(png_ptr, "Error msg")
+                   to exit and output any fatal error messages.
+   flush_data_fn - pointer to a new flush function which takes as its
+                   arguments a pointer to a png_struct.  After a call to
+                   the flush function, there should be no data in any buffers
+                   or pending transmission.  If the output method doesn't do
+                   any buffering of ouput, a function prototype must still be
+                   supplied although it doesn't have to do anything.  If
+                   PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
+                   time, output_flush_fn will be ignored, although it must be
+                   supplied for compatibility. */
+void
+png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
+   png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
+{
+   png_ptr->io_ptr = io_ptr;
+
+   if (write_data_fn)
+      png_ptr->write_data_fn = write_data_fn;
+   else
+      png_ptr->write_data_fn = png_default_write_data;
+
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+   if (output_flush_fn)
+      png_ptr->output_flush_fn = output_flush_fn;
+   else
+      png_ptr->output_flush_fn = png_default_flush;
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+
+   /* It is an error to read while writing a png file */
+   png_ptr->read_data_fn = NULL;
+}
+

pngwrite.c

@@ -1,10 +1,10 @@
 
 /* pngwrite.c - general routines to write a png file
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
    */
 
 /* get internal access to png.h */
@@ -16,7 +16,7 @@
    write it, and put it in the correct location here.  If you want
    the chunk written after the image data, put it in png_write_end().
    I strongly encurage you to supply a PNG_INFO_ flag, and check
-	info->valid before writing the chunk, as that will keep the code
+   info->valid before writing the chunk, as that will keep the code
    from breaking if you want to just write a plain png file.
    If you have long comments, I suggest writing them in png_write_end(),
    and compressing them. */
@@ -48,6 +48,8 @@ png_write_info(png_structp png_ptr, png_infop info)
 #endif
    if (info->valid & PNG_INFO_PLTE)
       png_write_PLTE(png_ptr, info->palette, info->num_palette);
+   else if (info->color_type == PNG_COLOR_TYPE_PALETTE)
+      png_error(png_ptr, "Valid palette required for paletted images\n");
 #if defined(PNG_WRITE_tRNS_SUPPORTED)
    if (info->valid & PNG_INFO_tRNS)
       png_write_tRNS(png_ptr, info->trans, &(info->trans_values),
@@ -73,10 +75,13 @@ png_write_info(png_structp png_ptr, png_infop info)
 #endif
 #if defined(PNG_WRITE_tIME_SUPPORTED)
    if (info->valid & PNG_INFO_tIME)
+   {
       png_write_tIME(png_ptr, &(info->mod_time));
-   /* Check to see if we need to write text chunks */
+      png_ptr->flags |= PNG_FLAG_WROTE_tIME;
+   }
 #endif
 #if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
+   /* Check to see if we need to write text chunks */
    if (info->num_text)
    {
       int i; /* local counter */
@@ -88,10 +93,12 @@ png_write_info(png_structp png_ptr, png_infop info)
          if (info->text[i].compression >= 0)
          {
 #if defined(PNG_WRITE_zTXt_SUPPORTED)
-				/* write compressed chunk */
+            /* write compressed chunk */
             png_write_zTXt(png_ptr, info->text[i].key,
                info->text[i].text, info->text[i].text_length,
                info->text[i].compression);
+#else
+            png_warning(png_ptr, "Unable to write compressed text\n");
 #endif
          }
          else
@@ -99,7 +106,9 @@ png_write_info(png_structp png_ptr, png_infop info)
 #if defined(PNG_WRITE_tEXt_SUPPORTED)
             /* write uncompressed chunk */
             png_write_tEXt(png_ptr, info->text[i].key,
-					info->text[i].text, info->text[i].text_length);
+               info->text[i].text, info->text[i].text_length);
+#else
+            png_warning(png_ptr, "Unable to write uncompressed text\n");
 #endif
          }
       }
@@ -114,12 +123,16 @@ png_write_info(png_structp png_ptr, png_infop info)
 void
 png_write_end(png_structp png_ptr, png_infop info)
 {
-	/* see if user wants us to write information chunks */
+   if (!(png_ptr->mode & PNG_HAVE_IDAT))
+      png_error(png_ptr, "No IDATs written into file");
+
+   /* see if user wants us to write information chunks */
    if (info)
    {
 #if defined(PNG_WRITE_tIME_SUPPORTED)
       /* check to see if user has supplied a time chunk */
-      if (info->valid & PNG_INFO_tIME)
+      if (info->valid & PNG_INFO_tIME &&
+         !(png_ptr->flags & PNG_FLAG_WROTE_tIME))
          png_write_tIME(png_ptr, &(info->mod_time));
 #endif
 #if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
@@ -130,29 +143,34 @@ png_write_end(png_structp png_ptr, png_infop info)
 
          /* loop through comment chunks */
          for (i = 0; i < info->num_text; i++)
-			{
+         {
+#if defined(PNG_WRITE_zTXt_SUPPORTED)
             /* check to see if comment is to be compressed */
             if (info->text[i].compression >= 0)
             {
-#if defined(PNG_WRITE_zTXt_SUPPORTED)
                /* write compressed chunk */
                png_write_zTXt(png_ptr, info->text[i].key,
                   info->text[i].text, info->text[i].text_length,
                   info->text[i].compression);
-#endif
             }
-            else
-            {
 #if defined(PNG_WRITE_tEXt_SUPPORTED)
+            else
+#endif
+#endif
+#if defined(PNG_WRITE_tEXt_SUPPORTED)
+            {
                /* write uncompressed chunk */
                png_write_tEXt(png_ptr, info->text[i].key,
                   info->text[i].text, info->text[i].text_length);
+            }
 #endif
-				}
          }
       }
 #endif
    }
+
+   png_ptr->mode |= PNG_AFTER_IDAT;
+
    /* write end of png file */
    png_write_IEND(png_ptr);
 }
@@ -161,12 +179,12 @@ png_write_end(png_structp png_ptr, png_infop info)
 void
 png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
 {
-	ptime->year = (png_uint_16)(1900 + ttime->tm_year);
-	ptime->month = (png_byte)(ttime->tm_mon + 1);
-	ptime->day = (png_byte)ttime->tm_mday;
-	ptime->hour = (png_byte)ttime->tm_hour;
-	ptime->minute = (png_byte)ttime->tm_min;
-	ptime->second = (png_byte)ttime->tm_sec;
+   ptime->year = (png_uint_16)(1900 + ttime->tm_year);
+   ptime->month = (png_byte)(ttime->tm_mon + 1);
+   ptime->day = (png_byte)ttime->tm_mday;
+   ptime->hour = (png_byte)ttime->tm_hour;
+   ptime->minute = (png_byte)ttime->tm_min;
+   ptime->second = (png_byte)ttime->tm_sec;
 }
 
 void
@@ -180,37 +198,76 @@ png_convert_from_time_t(png_timep ptime, time_t ttime)
 #endif
 
 /* initialize png structure, and allocate any memory needed */
-void
-png_write_init(png_structp png_ptr)
+png_structp
+png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
+   png_error_ptr warn_fn, png_error_ptr error_fn)
 {
-   jmp_buf tmp_jmp; /* to save current jump buffer */
-	png_msg_ptr error_fn;
-	png_msg_ptr warning_fn;
-	png_voidp msg_ptr;
+   png_structp png_ptr;
 
-	/* save jump buffer and error functions */
-	png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
-	error_fn = png_ptr->error_fn;
-	warning_fn = png_ptr->warning_fn;
-	msg_ptr = png_ptr->msg_ptr;
+   if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
+   {
+      return (png_structp)NULL;
+   }
 
-	/* reset all variables to 0 */
-	png_memset(png_ptr, 0, sizeof (png_struct));
-	/* restore jump buffer and error functions */
-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
-	png_ptr->error_fn = error_fn;
-	png_ptr->warning_fn = warning_fn;
-	png_ptr->msg_ptr = msg_ptr;
+   if (setjmp(png_ptr->jmpbuf))
+   {
+      png_large_free(png_ptr, png_ptr->zbuf);
+      png_free(png_ptr, png_ptr->zstream);
+      png_destroy_struct(png_ptr);
+      return (png_structp)NULL;
+   }
+
+   png_set_error_fn(png_ptr, error_ptr, warn_fn, error_fn);
+
+   if (user_png_ver == NULL || strcmp(user_png_ver, png_libpng_ver))
+   {
+      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0])
+      {
+         png_error(png_ptr, "Incompatible libpng versions");
+      }
+      else
+      {
+         png_warning(png_ptr, "Different libpng versions");
+      }
+   }
 
    /* initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
    png_ptr->zbuf = png_large_malloc(png_ptr, png_ptr->zbuf_size);
+
+   png_set_write_fn(png_ptr, NULL, NULL, NULL);
+
+   png_ptr->do_free |= PNG_FREE_STRUCT;
+
+   return (png_ptr);
+}
+
+
+/* initialize png structure, and allocate any memory needed */
+void
+png_write_init(png_structp png_ptr)
+{
+   jmp_buf tmp_jmp; /* to save current jump buffer */
+
+   /* save jump buffer and error functions */
+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
+
+   /* reset all variables to 0 */
+   png_memset(png_ptr, 0, sizeof (png_struct));
+
+   /* restore jump buffer */
+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
+
+   /* initialize zbuf - compression buffer */
+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+   png_ptr->zbuf = png_large_malloc(png_ptr, png_ptr->zbuf_size);
+   png_set_write_fn(png_ptr, NULL, NULL, NULL);
 }
 
 /* write a few rows of image data.  If the image is interlaced,
    either you will have to write the 7 sub images, or, if you
    have called png_set_interlace_handling(), you will have to
-	"write" the image seven times */
+   "write" the image seven times */
 void
 png_write_rows(png_structp png_ptr, png_bytepp row,
    png_uint_32 num_rows)
@@ -248,7 +305,7 @@ png_write_image(png_structp png_ptr, png_bytepp image)
    }
 }
 
-/* write a row of image data */
+/* called by user to write a row of image data */
 void
 png_write_row(png_structp png_ptr, png_bytep row)
 {
@@ -264,7 +321,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
    {
       switch (png_ptr->pass)
       {
-			case 0:
+         case 0:
             if (png_ptr->row_number & 7)
             {
                png_write_finish_row(png_ptr);
@@ -282,7 +339,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
             if ((png_ptr->row_number & 7) != 4)
             {
                png_write_finish_row(png_ptr);
-					return;
+               return;
             }
             break;
          case 3:
@@ -300,7 +357,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
             }
             break;
          case 5:
-				if ((png_ptr->row_number & 1) || png_ptr->width < 2)
+            if ((png_ptr->row_number & 1) || png_ptr->width < 2)
             {
                png_write_finish_row(png_ptr);
                return;
@@ -318,12 +375,12 @@ png_write_row(png_structp png_ptr, png_bytep row)
 #endif
 
    /* set up row info for transformations */
-	png_ptr->row_info.color_type = png_ptr->color_type;
+   png_ptr->row_info.color_type = png_ptr->color_type;
    png_ptr->row_info.width = png_ptr->usr_width;
    png_ptr->row_info.channels = png_ptr->usr_channels;
    png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
-	png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
-		png_ptr->row_info.channels);
+   png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
+      png_ptr->row_info.channels);
    png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
       (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
 
@@ -336,7 +393,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
       (png_ptr->transformations & PNG_INTERLACE))
    {
       png_do_write_interlace(&(png_ptr->row_info),
-			png_ptr->row_buf + 1, png_ptr->pass);
+         png_ptr->row_buf + 1, png_ptr->pass);
       /* this should always get caught above, but still ... */
       if (!(png_ptr->row_info.width))
       {
@@ -350,72 +407,8 @@ png_write_row(png_structp png_ptr, png_bytep row)
    if (png_ptr->transformations)
       png_do_write_transformations(png_ptr);
 
-   /* filter rows that have been proved to help */
-   if (png_ptr->do_filter)
-   {
-      /* save row to previous row */
-		png_memcpy(png_ptr->save_row, png_ptr->row_buf,
-         (png_size_t)png_ptr->row_info.rowbytes + 1);
-
-      /* filter row */
-      png_write_filter_row(&(png_ptr->row_info), png_ptr->row_buf,
-         png_ptr->prev_row);
-
-      /* trade saved pointer and prev pointer so next row references are correctly */
-      { /* scope limiter */
-			png_bytep tptr;
-
-         tptr = png_ptr->prev_row;
-         png_ptr->prev_row = png_ptr->save_row;
-         png_ptr->save_row = tptr;
-      }
-   }
-   else
-      /* set filter row to "none" */
-		png_ptr->row_buf[0] = 0;
-
-   /* set up the zlib input buffer */
-   png_ptr->zstream->next_in = png_ptr->row_buf;
-   png_ptr->zstream->avail_in = (uInt)png_ptr->row_info.rowbytes + 1;
-   /* repeat until we have compressed all the data */
-   do
-   {
-      int ret; /* return of zlib */
-
-      /* compress the data */
-      ret = deflate(png_ptr->zstream, Z_NO_FLUSH);
-      /* check for compression errors */
-      if (ret != Z_OK)
-      {
-         if (png_ptr->zstream->msg)
-            png_error(png_ptr, png_ptr->zstream->msg);
-			else
-				png_error(png_ptr, "zlib error");
-      }
-
-      /* see if it is time to write another IDAT */
-      if (!png_ptr->zstream->avail_out)
-      {
-         /* write the IDAT and reset the zlib output buffer */
-         png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
-         png_ptr->zstream->next_out = png_ptr->zbuf;
-         png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
-      }
-   /* repeat until all data has been compressed */
-   } while (png_ptr->zstream->avail_in);
-
-	/* finish row - updates counters and flushes zlib if last row */
-	png_write_finish_row(png_ptr);
-
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
-	png_ptr->flush_rows++;
-
-	if (png_ptr->flush_dist > 0 &&
-		 png_ptr->flush_rows >= png_ptr->flush_dist)
-	{
-		png_write_flush(png_ptr);
-	}
-#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+   /* find a filter if necessary, filter the row and write it out */
+   png_write_find_filter(png_ptr, &(png_ptr->row_info));
 }
 
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
@@ -423,119 +416,239 @@ png_write_row(png_structp png_ptr, png_bytep row)
 void
 png_set_flush(png_structp png_ptr, int nrows)
 {
-	png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
+   png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
 }
 
 /* flush the current output buffers now */
 void
 png_write_flush(png_structp png_ptr)
 {
-	int wrote_IDAT;
+   int wrote_IDAT;
 
-	if (png_ptr->mode != PNG_HAVE_IDAT)
-	  return;
+   /* We have already written out all of the data */
+   if (png_ptr->row_number >= png_ptr->num_rows)
+     return;
 
-	do
-	{
-		int ret;
+   do
+   {
+      int ret;
 
-		/* compress the data */
-		ret = deflate(png_ptr->zstream, Z_SYNC_FLUSH);
-		wrote_IDAT = 0;
+      /* compress the data */
+      ret = deflate(png_ptr->zstream, Z_SYNC_FLUSH);
+      wrote_IDAT = 0;
 
-		/* check for compression errors */
-		if (ret != Z_OK)
-		{
-			if (png_ptr->zstream->msg)
-				png_error(png_ptr, png_ptr->zstream->msg);
-			else
-				png_error(png_ptr, "zlib error");
-		}
+      /* check for compression errors */
+      if (ret != Z_OK)
+      {
+         if (png_ptr->zstream->msg)
+            png_error(png_ptr, png_ptr->zstream->msg);
+         else
+            png_error(png_ptr, "zlib error");
+      }
 
-		if (!png_ptr->zstream->avail_out)
-		{
-			/* write the IDAT and reset the zlib output buffer */
-			png_write_IDAT(png_ptr, png_ptr->zbuf,
-								png_ptr->zbuf_size);
-			png_ptr->zstream->next_out = png_ptr->zbuf;
-			png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
-			wrote_IDAT = 1;
-		}
-	} while(wrote_IDAT == 1);
+      if (!png_ptr->zstream->avail_out)
+      {
+         /* write the IDAT and reset the zlib output buffer */
+         png_write_IDAT(png_ptr, png_ptr->zbuf,
+                        png_ptr->zbuf_size);
+         png_ptr->zstream->next_out = png_ptr->zbuf;
+         png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
+         wrote_IDAT = 1;
+      }
+   } while(wrote_IDAT == 1);
 
-	/* If there is any data left to be output, write it into a new IDAT */
-	if (png_ptr->zbuf_size != png_ptr->zstream->avail_out)
-	{
-		/* write the IDAT and reset the zlib output buffer */
-		png_write_IDAT(png_ptr, png_ptr->zbuf,
-							png_ptr->zbuf_size - png_ptr->zstream->avail_out);
-		png_ptr->zstream->next_out = png_ptr->zbuf;
-		png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
-	}
-	png_ptr->flush_rows = 0;
-	png_flush(png_ptr);
+   /* If there is any data left to be output, write it into a new IDAT */
+   if (png_ptr->zbuf_size != png_ptr->zstream->avail_out)
+   {
+      /* write the IDAT and reset the zlib output buffer */
+      png_write_IDAT(png_ptr, png_ptr->zbuf,
+                     png_ptr->zbuf_size - png_ptr->zstream->avail_out);
+      png_ptr->zstream->next_out = png_ptr->zbuf;
+      png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
+   }
+   png_ptr->flush_rows = 0;
+   png_flush(png_ptr);
 }
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 
+/* free all memory used by the write */
+void
+png_destroy_write_struct(png_structpp png_ptr, png_infopp info_ptr)
+{
+   if (info_ptr && *info_ptr)
+   {
+      png_destroy_struct((voidp)*info_ptr);
+      *info_ptr = (png_infop)NULL;
+   }
 
-/* free any memory used in png struct */
+   if (png_ptr && *png_ptr)
+   {
+      png_write_destroy(*png_ptr);
+      png_destroy_struct((voidp)*png_ptr);
+      *png_ptr = (png_structp)NULL;
+   }
+}
+
+
+/* free any memory used in png struct (old) */
 void
 png_write_destroy(png_structp png_ptr)
 {
-	jmp_buf tmp_jmp; /* save jump buffer */
+   jmp_buf tmp_jmp; /* save jump buffer */
+   png_error_ptr error_fn;
+   png_error_ptr warning_fn;
+   png_voidp error_ptr;
 
    /* free any memory zlib uses */
-	deflateEnd(png_ptr->zstream);
+   deflateEnd(png_ptr->zstream);
    png_free(png_ptr, png_ptr->zstream);
+
    /* free our memory.  png_free checks NULL for us. */
    png_large_free(png_ptr, png_ptr->zbuf);
    png_large_free(png_ptr, png_ptr->row_buf);
    png_large_free(png_ptr, png_ptr->prev_row);
-   png_large_free(png_ptr, png_ptr->save_row);
+   png_large_free(png_ptr, png_ptr->sub_row);
+   png_large_free(png_ptr, png_ptr->up_row);
+   png_large_free(png_ptr, png_ptr->avg_row);
+   png_large_free(png_ptr, png_ptr->paeth_row);
+
    /* reset structure */
    png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
+
+   error_fn = png_ptr->error_fn;
+   warning_fn = png_ptr->warning_fn;
+   error_ptr = png_ptr->error_ptr;
+
    png_memset(png_ptr, 0, sizeof (png_struct));
+
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
+   png_ptr->error_ptr = error_ptr;
+
    png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
 }
+
+/* Allow the application to select one or more filters to use */
 void
-png_set_filtering(png_structp png_ptr, int filter)
+png_set_filter(png_structp png_ptr, int method, int filters)
 {
-   png_ptr->do_custom_filter = 1;
-   png_ptr->do_filter = (png_byte)filter;
+   /* We allow 'method' only for future expansion of the base filter method */
+   if (method == 0)
+   {
+      switch (filters & (PNG_ALL_FILTERS | 0x07))
+      {
+         case 5:
+         case 6:
+         case 7: png_warning(png_ptr, "Unknown custom row filter for method 0");
+         case 0: png_ptr->do_filter = PNG_FILTER_NONE; break;
+         case 1: png_ptr->do_filter = PNG_FILTER_SUB; break;
+         case 2: png_ptr->do_filter = PNG_FILTER_UP; break;
+         case 3: png_ptr->do_filter = PNG_FILTER_AVG; break;
+         case 4: png_ptr->do_filter = PNG_FILTER_PAETH; break;
+         default: png_ptr->do_filter = (png_byte)filters; break;
+      }
+
+      /* If we have allocated the row_buf, then we should have also allocated
+       * all of the filter buffers that have been selected.
+       */
+      if (png_ptr->row_buf)
+      {
+         if (png_ptr->do_filter & PNG_FILTER_SUB && !(png_ptr->sub_row))
+         {
+            png_ptr->sub_row = (png_bytep )png_large_malloc(png_ptr,
+               png_ptr->rowbytes + 1);
+            png_ptr->sub_row[0] = 1;  /* Set the row filter type */
+         }
+
+         if (png_ptr->do_filter & PNG_FILTER_UP && !(png_ptr->up_row))
+         {
+            if (!(png_ptr->prev_row))
+            {
+               png_warning(png_ptr, "Can't to add up filter after starting");
+               png_ptr->do_filter &= ~PNG_FILTER_UP;
+            }
+            else
+            {
+               png_ptr->up_row = (png_bytep )png_large_malloc(png_ptr,
+                  png_ptr->rowbytes + 1);
+               png_ptr->up_row[0] = 2;  /* Set the row filter type */
+            }
+         }
+
+         if (png_ptr->do_filter & PNG_FILTER_AVG && !(png_ptr->avg_row))
+         {
+            if (!(png_ptr->prev_row))
+            {
+               png_warning(png_ptr, "Can't add average filter after starting");
+               png_ptr->do_filter &= ~PNG_FILTER_AVG;
+            }
+            else
+            {
+               png_ptr->up_row = (png_bytep )png_large_malloc(png_ptr,
+                  png_ptr->rowbytes + 1);
+               png_ptr->up_row[0] = 3;  /* Set the row filter type */
+            }
+         }
+
+         if (png_ptr->do_filter & PNG_FILTER_PAETH && !(png_ptr->paeth_row))
+         {
+            if (!(png_ptr->prev_row))
+            {
+               png_warning(png_ptr, "Can't add Paeth filter after starting");
+               png_ptr->do_filter &= ~PNG_FILTER_PAETH;
+            }
+            else
+            {
+               png_ptr->paeth_row = (png_bytep )png_large_malloc(png_ptr,
+                  png_ptr->rowbytes + 1);
+               png_ptr->paeth_row[0] = 4;  /* Set the row filter type */
+            }
+         }
+
+         if (png_ptr->do_filter == PNG_NO_FILTERS)
+            png_ptr->do_filter = PNG_FILTER_NONE;
+      }
+   }
+   else
+     png_error(png_ptr, "Unknown custom filter method");
 }
 
 void
 png_set_compression_level(png_structp png_ptr, int level)
 {
-   png_ptr->zlib_custom_level = 1;
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
    png_ptr->zlib_level = level;
 }
 
 void
 png_set_compression_mem_level(png_structp png_ptr, int mem_level)
 {
-   png_ptr->zlib_custom_mem_level = 1;
-	png_ptr->zlib_mem_level = mem_level;
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
+   png_ptr->zlib_mem_level = mem_level;
 }
 
 void
 png_set_compression_strategy(png_structp png_ptr, int strategy)
 {
-   png_ptr->zlib_custom_strategy = 1;
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
    png_ptr->zlib_strategy = strategy;
 }
 
 void
 png_set_compression_window_bits(png_structp png_ptr, int window_bits)
 {
-   png_ptr->zlib_custom_window_bits = 1;
+   if (window_bits > 15)
+      png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
    png_ptr->zlib_window_bits = window_bits;
 }
 
 void
 png_set_compression_method(png_structp png_ptr, int method)
 {
-   png_ptr->zlib_custom_method = 1;
+   if (method != 8)
+      png_warning(png_ptr, "Only compression method 8 is supported by PNG");
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;
    png_ptr->zlib_method = method;
 }
 

pngwtran.c

@@ -1,10 +1,10 @@
 
 /* pngwtran.c - transforms the data in a row for png writers
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 3 - version 0.89
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   May 25, 1996
    */
 
 #define PNG_INTERNAL
@@ -18,7 +18,7 @@ png_do_write_transformations(png_structp png_ptr)
 #if defined(PNG_WRITE_FILLER_SUPPORTED)
    if (png_ptr->transformations & PNG_FILLER)
       png_do_write_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
-         png_ptr->filler_loc);
+         png_ptr->flags);
 #endif
 #if defined(PNG_WRITE_PACK_SUPPORTED)
    if (png_ptr->transformations & PNG_PACK)
@@ -60,8 +60,8 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
          {
             png_bytep sp;
             png_bytep dp;
-				int mask;
-				png_int_32 i;
+            int mask;
+            png_int_32 i;
             int v;
 
             sp = row;
@@ -78,13 +78,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
                else
                {
                   mask = 0x80;
-						*dp = (png_byte)v;
-						dp++;
+                  *dp = (png_byte)v;
+                  dp++;
                   v = 0;
                }
             }
             if (mask != 0x80)
-					*dp = (png_byte)v;
+               *dp = (png_byte)v;
             break;
          }
          case 2:
@@ -94,7 +94,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
             int shift;
             png_int_32 i;
             int v;
-				png_byte value;
+            png_byte value;
 
             sp = row;
             dp = row;
@@ -102,12 +102,12 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
             v = 0;
             for (i = 0; i < row_info->width; i++)
             {
-					value = (png_byte)(*sp & 0x3);
+               value = (png_byte)(*sp & 0x3);
                v |= (value << shift);
                if (shift == 0)
                {
                   shift = 6;
-						*dp = (png_byte)v;
+                  *dp = (png_byte)v;
                   dp++;
                   v = 0;
                }
@@ -116,7 +116,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
                sp++;
             }
             if (shift != 6)
-					*dp = (png_byte)v;
+               *dp = (png_byte)v;
             break;
          }
          case 4:
@@ -134,13 +134,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
             v = 0;
             for (i = 0; i < row_info->width; i++)
             {
-					value = (png_byte)(*sp & 0xf);
+               value = (png_byte)(*sp & 0xf);
                v |= (value << shift);
 
                if (shift == 0)
                {
                   shift = 4;
-						*dp = (png_byte)v;
+                  *dp = (png_byte)v;
                   dp++;
                   v = 0;
                }
@@ -150,12 +150,12 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
                sp++;
             }
             if (shift != 4)
-					*dp = (png_byte)v;
+               *dp = (png_byte)v;
             break;
          }
       }
       row_info->bit_depth = bit_depth;
-		row_info->pixel_depth = (png_uint_16)(bit_depth * row_info->channels);
+      row_info->pixel_depth = (png_uint_16)(bit_depth * row_info->channels);
       row_info->rowbytes =
          ((row_info->width * row_info->pixel_depth + 7) >> 3);
    }
@@ -276,8 +276,8 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
             {
                png_uint_16 value, v;
 
-					v = (png_uint_16)(((png_uint_16)(*bp) << 8) +
-						(png_uint_16)(*(bp + 1)));
+               v = (png_uint_16)(((png_uint_16)(*bp) << 8) +
+                  (png_uint_16)(*(bp + 1)));
                value = 0;
                for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
                {
@@ -286,7 +286,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
                   else
                      value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
                }
-					*bp = (png_byte)(value >> 8);
+               *bp = (png_byte)(value >> 8);
                *(bp + 1) = (png_byte)(value & 0xff);
             }
          }
@@ -299,12 +299,12 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
 /* remove filler byte */
 void
 png_do_write_filler(png_row_infop row_info, png_bytep row,
-   png_byte filler_loc)
+   png_byte flags)
 {
    if (row && row_info && row_info->color_type == PNG_COLOR_TYPE_RGB &&
       row_info->bit_depth == 8)
    {
-      if (filler_loc == PNG_FILLER_AFTER)
+      if (flags & PNG_FLAG_FILLER_AFTER)
       {
          png_bytep sp, dp;
 
@@ -325,7 +325,7 @@ png_do_write_filler(png_row_infop row_info, png_bytep row,
       }
       else
       {
-			png_bytep sp, dp;
+         png_bytep sp, dp;
          png_uint_32 i;
 
          for (i = 0, sp = row, dp = row;

readme.txt

@@ -1,41 +1,56 @@
-readme.txt - for libpng 0.87
+readme.txt - for libpng 0.89
 
-This is a bug fix for the second beta version of libpng 1.0, and
-a first try at a progressive (push) reader.  It hasn't been
-tested as much as the pull reader, but seems to work ok.
+This is a bug fix for the third beta version of libpng 1.0.  The
+changes from libpng-0.88 are bug fixes and some changes to the
+API itself to increase robustness with shared libraries.  This
+release is based on libpng-0.88, but has been modified from that
+version by Andreas Dilger <adilger@enel.ucalgary.ca> because the
+original author, Guy Schalnat, has not been able to keep up with
+the time demands of maintaining this library.
 
-I've implemented the callback functions for the error/warning
-messages and the input/output.  See the libpng.txt
-for details.  I've also added defines to support medium memory
-models, so every type now has pointer defines.  For example,
-a pointer to the png_struct is now png_structp, while a double
-pointer is now png_structpp.  The old way should work, but I'll
-be using the new way from now on in all my examples.  Those of
-you doing medium memory model or changing the error/warning
-or input/output functions should try these and report back to
-me any problems.
+The callback functions for the error/warning messages have changed
+since the last release because their implementation was broken,
+and it was thought best to change the API itself (which was only
+introduced in libpng-0.88 itself) to alert the user to the change,
+rather than mislead the user into thinking their application was
+OK after re-compiling.  This means that calls to png_set_message_fn()
+no longer exist, because the previously suggested method of calling
+them before png_read_init() or png_write_init() is now ineffective.
 
-I've tried to incorporate all the changes and makefiles everyone
-sent me.  However, I may of lost some in the flood.  If you sent
-me a change and I didn't put it in, send it again.  Sorry.
+The preferred method of setting the error and warning callbacks
+has been incorporated into the allocation of the png_struct and
+info_struct itself, which allow them to be safely used during the
+initialization of the structure, as well as to keep the size of
+the png_struct internal to the library, rather than at compile time
+of the application.  This will hopefully remove any problems with
+dynamically linked libraries, and should be considered the preferred
+method of creating these structures, although the previous
+initialization API is still available for compatibility.  See libpng.txt
+for more information on the new API.
+
+The changes made to the library, and bugs fixed are based on discussions
+on the PNG implementation mailing list <png-implement@dworking.wustl.edu>
+and not on material submitted to Guy.
 
 For a detailed description on using libpng, read libpng.txt.  For
 usage information and restrictions (what little they are) on libpng,
 see png.h.  For a description on using zlib (the compression library
 used by libpng) and zlib's restrictions, see zlib.h
 
-I have included a general makefile, but you may have to modify it
-for your own needs.
+I have included a general makefile, as well as several machine and compiler
+specific ones, but you may have to modify one for your own needs.
 
 You will need zlib 0.95 or later to run this.  zlib is a compression
 library that is useful for more things then just png files.  If
-you need a compression library, check out zlib.h
+you need a compression library, check out zlib.h.  There was a bug in
+zlib <= 0.99 which caused it to generate invalid compression streams
+on some occasions.  Later versions of zlib do not have this problem.
 
 zlib should be available at the same place that libpng is.
 If not, it should be at ftp.uu.net in /graphics/png
 Eventually, it will be at ftp.uu.net in /pub/archiving/zip/zlib
 
-You will also want a copy of the PNG specification.  It should
+You may also want a copy of the PNG specification.  It should
 be available at the same place you picked up libpng.  If it is
 not there, try ftp.uu.net in the /graphics/png directory.
 
@@ -55,17 +70,18 @@ Finally, if you get any warning messages when compiling libpng
 (note: not zlib), and they are easy to fix, I'd appreciate the
 fix.  Please mention "libpng" somewhere in the subject line.  Thanks.
 
-You can reach me at:
+This release was created and will be supported by myself, and the
+PNG group.
+
+adilger@enel.ucalgary.ca
+png-implement@dworkin.wustl.edu
+
+You can reach Guy, the original libpng author, at (internet preferred):
 
 internet: schalnat@group42.com
 CompuServe: 75501,1625
 
-I tend to check my CompuServe account very infrequently, so you may
-want to use the internet account.  If I don't answer your email
-immediately, please be patient.  If you don't receive a reply within
-a week, you may want to write and ask if I got the first email.
-
-Please do not send me general questions about PNG.  Send them to
+Please do not send general questions about PNG.  Send them to
 the address in the specification.  At the same time, please do
 not send libpng questions to that address, send them to me.  I'll
 get them in the end anyway.  If you have a question about something