Imported from libpng-0.88.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,50 @@
+
+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,\
+	pngio.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
+pngio.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 */
@@ -82,18 +82,18 @@ void read_png(char *file_name)
    /* 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 */
+   /* if you are using replacement read functions, here you would call */
-	png_set_read_fn(png_ptr, (void *)io_ptr, user_read_fn);
+   png_set_read_fn(png_ptr, (void *)io_ptr, user_read_fn);
-	/* where io_ptr is a structure you want available to the callbacks */
+   /* where io_ptr is a structure you want available to the callbacks */
 
-	/* if you are using replacement message functions, here you would call */
+   /* 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);
+   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 */
+   /* where msg_ptr is a structure you want available to the callbacks */
 
-	/* read the file information */
+   /* read the file information */
-	png_read_info(png_ptr, info_ptr);
+   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 */
@@ -110,14 +110,14 @@ void read_png(char *file_name)
       png_set_expand(png_ptr);
 
    /* Set the background color to draw transparent and alpha
-		images over */
+      images over */
    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);
+         PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
-	else
+   else
-		png_set_background(png_ptr, &my_background,
+      png_set_background(png_ptr, &my_background,
          PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
 
    /* tell libpng to handle the gamma conversion for you */
@@ -128,7 +128,7 @@ void read_png(char *file_name)
 
    /* tell libpng to strip 16 bit depth files down to 8 bits */
    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
       to the number of colors available on your screen */
@@ -146,7 +146,7 @@ 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 &&
@@ -164,7 +164,7 @@ void read_png(char *file_name)
 
    /* 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 */
@@ -182,7 +182,7 @@ void read_png(char *file_name)
    else
       number_passes = 1;
 
-	/* optional call to update palette with transformations */
+   /* optional call to update palette with transformations */
    png_start_read_image(png_ptr);
 
    /* optional call to update the info structure */
@@ -200,7 +200,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++)
@@ -218,7 +218,7 @@ void read_png(char *file_name)
 
    /* read the rest of the file, getting any additional chunks
       in info_ptr */
-	png_read_end(png_ptr, 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);
@@ -237,126 +237,126 @@ 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 */
+   reading in one image at a time */
 png_structp png_ptr;
 png_infop info_ptr;
 
 int
 initialize_png_reader()
 {
-	png_ptr = malloc(sizeof (png_struct));
+   png_ptr = malloc(sizeof (png_struct));
-	if (!png_ptr)
+   if (!png_ptr)
-		return -1;
+      return -1;
-	info_ptr = malloc(sizeof (png_info));
+   info_ptr = malloc(sizeof (png_info));
-	if (!info_ptr)
+   if (!info_ptr)
-	{
+   {
-		free(png_ptr);
+      free(png_ptr);
-		return -1;
+      return -1;
-	}
+   }
 
-	if (setjmp(png_ptr->jmpbuf))
+   if (setjmp(png_ptr->jmpbuf))
-	{
+   {
-		png_read_destroy(png_ptr, info_ptr, (png_info *)0);
+      png_read_destroy(png_ptr, info_ptr, (png_info *)0);
-		/* free pointers before returning, if necessary */
+      /* free pointers before returning, if necessary */
-		free(png_ptr);
+      free(png_ptr);
-		free(info_ptr);
+      free(info_ptr);
-		return -1;
+      return -1;
-	}
+   }
 
-	png_info_init(info_ptr);
+   png_info_init(info_ptr);
-	png_read_init(png_ptr);
+   png_read_init(png_ptr);
 
-	/* this one's new.  You will need to provide all three
+   /* this one's new.  You will need to provide all three
-		function callbacks, even if you aren't using them all.
+      function callbacks, even if you aren't using them all.
-		You can put a void pointer in place of the NULL, and
+      You can put a void pointer in place of the NULL, and
-		retrieve the pointer from inside the callbacks using
+      retrieve the pointer from inside the callbacks using
-		the function png_get_progressive_ptr(png_ptr); */
+      the function png_get_progressive_ptr(png_ptr); */
-	png_set_progressive_read_fn(png_ptr, NULL,
+   png_set_progressive_read_fn(png_ptr, NULL,
-		info_callback, row_callback, end_callback);
+      info_callback, row_callback, end_callback);
 
-	return 0;
+   return 0;
 }
 
 int
 process_data(png_bytep buffer, png_uint_32 length)
 {
-	if (setjmp(png_ptr->jmpbuf))
+   if (setjmp(png_ptr->jmpbuf))
-	{
+   {
-		png_read_destroy(png_ptr, info_ptr, (png_info *)0);
+      png_read_destroy(png_ptr, info_ptr, (png_info *)0);
-		free(png_ptr);
+      free(png_ptr);
-		free(info_ptr);
+      free(info_ptr);
-		return -1;
+      return -1;
-	}
+   }
 
-	/* this one's new also.  Simply give it a chunk of data
+   /* this one's new also.  Simply give it a chunk of data
-		from the file stream (in order, of course).  On Segmented
+      from the file stream (in order, of course).  On Segmented
-		machines, don't give it any more then 64K.  The library
+      machines, don't give it any more then 64K.  The library
-		seems to run fine with sizes of 4K, although you can give
+      seems to run fine with sizes of 4K, although you can give
-		it much less if necessary (I assume you can give it chunks
+      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).
+      of 1 byte, but I haven't tried less then 256 bytes yet).
-		When this function returns, you may want to display any
+      When this function returns, you may want to display any
-		rows that were generated in the row callback. */
+      rows that were generated in the row callback. */
-	png_process_data(png_ptr, info_ptr, buffer, length);
+   png_process_data(png_ptr, info_ptr, buffer, length);
-	return 0;
+   return 0;
 }
 
 info_callback(png_structp png_ptr, png_infop info)
 {
-/*	do any setup here, including setting any of the transformations
+/* do any setup here, including setting any of the transformations
-	mentioned in the Reading PNG files section.  For now, you _must_
+   mentioned in the Reading PNG files section.  For now, you _must_
-	call either png_start_read_image() or png_read_update_info()
+   call either png_start_read_image() or png_read_update_info()
-	after all the transformations are set (even if you don't set
+   after all the transformations are set (even if you don't set
-	any).  You may start getting rows before png_process_data()
+   any).  You may start getting rows before png_process_data()
-	returns, so this is your last chance to prepare for that. */
+   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
+/* this function is called for every row in the image.  If the
-	image is interlacing, and you turned on the interlace handler,
+   image is interlacing, and you turned on the interlace handler,
-	this function will be called for every row in every pass.
+   this function will be called for every row in every pass.
-	Some of these rows will not be changed from the previous 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.
+   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
+   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
+   need the row_num and pass, but I'm supplying them because it
-	may make your life easier.
+   may make your life easier.
 
-	For the non-NULL rows of interlaced images, you must call
+   For the non-NULL rows of interlaced images, you must call
-	png_progressive_combine_row() passing in the row and the
+   png_progressive_combine_row() passing in the row and the
-	old row.  You can call this function for NULL rows (it will
+   old row.  You can call this function for NULL rows (it will
-	just return) and for non-interlaced images (it just does the
+   just return) and for non-interlaced images (it just does the
-	memcpy for you) if it will make the code easier.  Thus, you
+   memcpy for you) if it will make the code easier.  Thus, you
-	can just do this for all cases: */
+   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
+/* where old_row is what was displayed for previous rows.  Note
-	that the first pass (pass == 0 really) will completely cover
+   that the first pass (pass == 0 really) will completely cover
-	the old row, so the rows do not have to be initialized.  After
+   the old row, so the rows do not have to be initialized.  After
-	the first pass (and only for interlaced images), you will have
+   the first pass (and only for interlaced images), you will have
-	to pass the current row, and the function will combine the
+   to pass the current row, and the function will combine the
-	old row and the new row. */
+   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,
+/* this function is called when the whole image has been read,
-	including any chunks after the image (up to and including
+   including any chunks after the image (up to and including
-	the IEND).  You will usually have the same info chunk as you
+   the IEND).  You will usually have the same info chunk as you
-	had in the header, although some data may have been added
+   had in the header, although some data may have been added
-	to the comments and time fields.
+   to the comments and time fields.
 
-	Most people won't do much here, perhaps setting a flag that
+   Most people won't do much here, perhaps setting a flag that
-	marks the image as finished. */
+   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_structp png_ptr;
-	png_infop info_ptr;
+   png_infop info_ptr;
 
    /* open the file */
    fp = fopen(file_name, "wb");
@@ -380,7 +380,7 @@ void write_png(char *file_name, ... other image information ...)
    }
 
    /* set error handling */
-	if (setjmp(png_ptr->jmpbuf))
+   if (setjmp(png_ptr->jmpbuf))
    {
       png_write_destroy(png_ptr);
       fclose(fp);
@@ -397,15 +397,15 @@ void write_png(char *file_name, ... other image information ...)
    /* 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 */
+   /* 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);
+   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 */
+   /* where io_ptr is a structure you want available to the callbacks */
 
-	/* if you are using replacement message functions, here you would call */
+   /* 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);
+   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 */
+   /* 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,18 +418,18 @@ 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 */
+   /* if we are dealing with a grayscale image then */
-	info_ptr->sig_bit.gray = true_bit_depth;
+   info_ptr->sig_bit.gray = true_bit_depth;
-	/* otherwise, if we are dealing with a color image then */
+   /* otherwise, if we are dealing with a color image then */
-	info_ptr->sig_bit.red = true_red_bit_depth;
+   info_ptr->sig_bit.red = true_red_bit_depth;
-	info_ptr->sig_bit.green = true_green_bit_depth;
+   info_ptr->sig_bit.green = true_green_bit_depth;
-	info_ptr->sig_bit.blue = true_blue_bit_depth;
+   info_ptr->sig_bit.blue = true_blue_bit_depth;
-	/* if the image has an alpha channel then */
+   /* 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
+   /* optional gamma chunk is strongly suggested if you have any guess
-	   as to the correct gamma of the image */
+      as to the correct gamma of the image */
-	info_ptr->valid |= PNG_INFO_gAMA;
+   info_ptr->valid |= PNG_INFO_gAMA;
    info_ptr->gamma = gamma;
 
    /* other optional chunks */

makefile

@@ -2,15 +2,15 @@
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 # For conditions of distribution and use, see copyright notice in png.h
 
-CC=gcc
+CC=cc
-CFLAGS=-I../zlib -O2 -Wall
+CFLAGS=-I../zlib -O
 LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
 
-RANLIB=ranlib
+#RANLIB=ranlib
-#RANLIB=echo
+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 \
@@ -31,12 +31,11 @@ test: pngtest
 install: libpng.a
 	-@mkdir $(prefix)/include
 	-@mkdir $(prefix)/lib
-	cp png.h pngconf.h $(prefix)/include
+	cp png.h $(prefix)/include
-	rcp png.h pngconf.h vlsi:bin/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:

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 pngio.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)(pngio.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) \
+ pngrcb.$(O) \
+ pngrutil.$(O) \
+ pngtrans.$(O) \
+ pngwutil.$(O) \
+ pngmem.$(O) \
+ pngread.$(O) \
+ pngpread.$(O) \
+ pngerror.$(O) \
+ pngwrite.$(O) \
+ pngrtran.$(O) \
+ pngwtran.$(O) \
+ pngzlib.$(O) \
+ pngio.$(O)
+
+LIBOBJS = \
+ +png.$(O) \
+ +pngrcb.$(O) \
+ +pngrutil.$(O) \
+ +pngtrans.$(O) \
+ +pngwutil.$(O) \
+ +pngmem.$(O) \
+ +pngpread.$(O) \
+ +pngread.$(O) \
+ +pngerror.$(O) \
+ +pngwrite.$(O) \
+ +pngrtran.$(O) \
+ +pngwtran.$(O) \
+ +pngzlib.$(O) \
+ +pngio.$(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
+pngio.obj: pngio.c
+pngtrans.obj: pngtrans.c
+pngwrite.obj: pngwrite.c
+pngwtran.obj: pngwtran.c
+pngwutil.obj: pngwutil.c
+pngzlib.obj: pngzlib.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.elf

@@ -9,7 +9,7 @@ LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
 RANLIB=ranlib
 #RANLIB=echo
 
-PNGVER = 0.87
+PNGVER = 0.86
 
 # where make install puts libpng.a, libpng.so*, and png.h
 prefix=/usr/local

makefile.gcc

@@ -0,0 +1,50 @@
+# gcc/DOS 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 pngio.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
+pngio.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.knr

@@ -0,0 +1,71 @@
+# 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 pngio.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
+pngio.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,60 @@
+# 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 pngio.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
+pngio.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,78 @@
+# 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) pngio$(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)
+
+pngio$(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,60 @@
+# 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 pngio.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
+pngio.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,69 @@
+# 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) pngio$(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) pngio$(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
+
+pngio$(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,121 @@
+$! 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 pngio.OBJ "cc ''CCOPT' pngio" -
+                pngio.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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 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.88";
 
 /* place to hold the signiture string for a png file. */
 png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
@@ -95,7 +95,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 +107,22 @@ png_check_sig(png_bytep sig, int num)
 voidpf
 png_zalloc(voidpf png_ptr, uInt items, uInt size)
 {
-	png_voidp ptr;
+   png_voidp ptr;
-	png_uint_32 num_bytes;
+   png_uint_32 num_bytes;
 
-	ptr = png_large_malloc((png_structp)png_ptr,
+   ptr = png_large_malloc((png_structp)png_ptr,
-		(png_uint_32)items * (png_uint_32)size);
+      (png_uint_32)items * (png_uint_32)size);
-	num_bytes = (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)
+   if (num_bytes > (png_uint_32)0x7fff)
-	{
+   {
-		png_memset(ptr, 0, (png_size_t)0x8000L);
+      png_memset(ptr, 0, (png_size_t)0x8000L);
-		png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
+      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
-			(png_size_t)(num_bytes - (png_uint_32)0x8000L));
+         (png_size_t)(num_bytes - (png_uint_32)0x8000L));
-	}
+   }
-	else
+   else
-	{
+   {
-		png_memset(ptr, 0, (png_size_t)num_bytes);
+      png_memset(ptr, 0, (png_size_t)num_bytes);
-	}
+   }
    return (voidpf)(ptr);
 }
 
@@ -130,7 +130,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 +143,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
+   PNG spec, with appropriate modifications made to ensure the
-	variables are large enough */
+   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 +193,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;
@@ -213,6 +213,6 @@ 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));
 }
 

png.h

@@ -1,8 +1,8 @@
 
 /* png.h - header file for png reference library
 
-   libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 2 - version 0.88
-   Jan 15, 1996
+   Jan 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
@@ -27,7 +27,7 @@
    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,
@@ -41,9 +41,9 @@
    to the following restrictions:
    1. The origin of this source code must not be misrepresented.
    2. Altered versions must be plainly marked as such and must not be
-      misrepresented as being the original source.
+     misrepresented as being the original source.
    3. This Copyright notice may not be removed or altered from any source or
-      altered source distribution.
+     altered source distribution.
 
    The Contributing Authors and Group 42, Inc. specifically permit, without
    fee, and encourage the use of this source code as a component to
@@ -74,10 +74,10 @@
 
 /* version information for png.h - this should match the version
    number in png.c */
-#define PNG_LIBPNG_VER_STRING "0.87"
+#define PNG_LIBPNG_VER_STRING "0.88"
-/* careful here.  I wanted to use 087, but that would be octal.  Version
+/* careful here.  I wanted to use 088, but that would be octal.  Version
    1.0 will be 100 here, etc. */
-#define PNG_LIBPNG_VER 87
+#define PNG_LIBPNG_VER 88
 
 /* variables defined in png.c - only it needs to define PNG_NO_EXTERN */
 #ifndef PNG_NO_EXTERN
@@ -99,7 +99,7 @@ typedef struct png_color_struct
    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 +110,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 +121,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 +133,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.
@@ -150,7 +150,7 @@ typedef struct png_time_struct
    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.
@@ -231,7 +231,7 @@ typedef struct png_info_struct
    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
@@ -287,7 +287,7 @@ 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

pngchang.txt

@@ -1,31 +1,31 @@
 pngchange.txt - changes for libpng
 
 version 0.2
-	added reader into png.h
+   added reader into png.h
-	fixed small problems in stub file
+   fixed small problems in stub file
 version 0.3
-	added pull reader
+   added pull reader
-	split up pngwrite.c to several files
+   split up pngwrite.c to several files
-	added pnglib.txt
+   added pnglib.txt
-	added example.c
+   added example.c
-	cleaned up writer, adding a few new tranformations
+   cleaned up writer, adding a few new tranformations
-	fixed some bugs in writer
+   fixed some bugs in writer
-	interfaced with zlib 0.5
+   interfaced with zlib 0.5
-	added K&R support
+   added K&R support
-	added check for 64 KB blocks for 16 bit machines
+   added check for 64 KB blocks for 16 bit machines
 version 0.4
-	cleaned up code and commented code
+   cleaned up code and commented code
-	simplified time handling into png_time
+   simplified time handling into png_time
-	created png_color_16 and png_color_8 to handle color needs
+   created png_color_16 and png_color_8 to handle color needs
-	cleaned up color type defines
+   cleaned up color type defines
-	fixed various bugs
+   fixed various bugs
-	made various names more consistant
+   made various names more consistant
-	interfaced with zlib 0.71
+   interfaced with zlib 0.71
-	cleaned up zTXt reader and writer (using zlib's Reset functions)
+   cleaned up zTXt reader and writer (using zlib's Reset functions)
-	split transformations into pngrtran.c and pngwtran.c
+   split transformations into pngrtran.c and pngwtran.c
 version 0.5
-	interfaced with zlib 0.8
+   interfaced with zlib 0.8
-	fixed many reading and writing bugs
+   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,10 @@ version 0.86
    fixed bugs
    improved documentation
 version 0.87
-	fixed medium model bugs
+   fixed medium model bugs
-	fixed other bugs introduced in 0.85 and 0.86
+   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

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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 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:
+   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
+   stdin, stdout, and stderr.  The only one currently used is stderr
-	in png_error() and png_warning().  #defining PNG_NO_STDIO will
+   in png_error() and png_warning().  #defining PNG_NO_STDIO will
-	prevent these from being compiled and used. */
+   prevent these from being compiled and used. */
 
 /* #define PNG_NO_STDIO */
 
@@ -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.
+   and warning message functions, so some compilers won't complain.
-	If you want to use const, define PNG_USE_CONST here.  It is not
+   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
+   normally defined to make configuration easier, as it is not a
    critical part of the code.
-	*/
+   */
 
 #ifdef PNG_USE_CONST
 #  define PNG_CONST const
@@ -260,7 +260,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 +269,7 @@ typedef size_t png_size_t;
 */
 #endif  /* __WIN32__, __FLAT__ */
 
-#endif	/* __BORLANDC__ */
+#endif   /* __BORLANDC__ */
 
 
 /* SJT:  Suggest testing for specific compiler first before
@@ -303,7 +303,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 +341,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 +349,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,107 @@
 
 /* pngerror.c - stub functions for i/o and memory allocation
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 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
+   and use png_set_message_fn() to use those functions.  See the instructions
-	at each function. */
+   at each function. */
 
 #define PNG_INTERNAL
 #include "png.h"
 
 /* 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,
+   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()
+   you should supply a replacement error function and use png_set_message_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)
+   if (png_ptr->error_fn)
-		(*(png_ptr->error_fn))(png_ptr, message);
+      (*(png_ptr->error_fn))(png_ptr, message);
 
-	/* if the following returns or doesn't exist, use the default function,
+   /* if the following returns or doesn't exist, use the default function,
-	   which will not return */
+      which will not return */
-	png_default_error(png_ptr, message);
+   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,
+   should not be changed.  If there is a need to handle warnings differently,
-	you should supply a replacement warning function and use
+   you should supply a replacement warning function and use
-	png_set_message_fn() to replace the warning function at run-time. */
+   png_set_message_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)
+   if (png_ptr->warning_fn)
-		(*(png_ptr->warning_fn))(png_ptr, message);
+      (*(png_ptr->warning_fn))(png_ptr, message);
-	else
+   else
-		png_default_warning(png_ptr, message);
+      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
+   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
+   function is used by default, or if the program supplies NULL for the
-	error function pointer in png_set_message_fn(). */
+   error function pointer in png_set_message_fn(). */
 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;
+      jmp_buf jmpbuf;
-		png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
+      png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
-		longjmp(jmpbuf, 1);
+      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
+   it can continue anyway.  Replacement functions don't have to do anything
-	here if you don't want to.  In the default configuration, png_ptr is
+   here if you don't want to.  In the default configuration, png_ptr is
    not used, but it is passed in case it may be useful. */
 void
 png_default_warning(png_structp png_ptr, png_const_charp message)
 {
-	if (!png_ptr)
+   if (!png_ptr)
-		return;
+      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
+   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 to the calling routine or serious problems will occur. The error
-	return method used in the default routine calls
+   return method used in the default routine calls
-	longjmp(png_ptr->jmpbuf, 1) */
+   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_msg_ptr warning_fn)
 {
-	png_ptr->msg_ptr = msg_ptr;
+   png_ptr->msg_ptr = msg_ptr;
 
-	png_ptr->error_fn = error_fn;
+   png_ptr->error_fn = error_fn;
-	png_ptr->warning_fn = warning_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
+   functions.  The application should free any memory associated with this
-	pointer before png_write_destroy and png_read_destroy are called. */
+   pointer before png_write_destroy and png_read_destroy are called. */
 png_voidp
 png_get_msg_ptr(png_structp png_ptr)
 {
-	return png_ptr->msg_ptr;
+   return png_ptr->msg_ptr;
 }
 
 

pngio.c

@@ -1,41 +1,41 @@
 
 /* pngio.c - stub functions for i/o and memory allocation
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 25, 1996
 
    This file provides a location for all input/output.  Users which need
-	special handling are expected to write functions which have the same
+   special handling are expected to write functions which have the same
-	arguments as these, and perform similar functions, but possibly have
+   arguments as these, and perform similar functions, but possibly have
-	different I/O methods.  Note that you shouldn't change these functions,
+   different I/O methods.  Note that you shouldn't change these functions,
-	but rather write replacement functions and then change them at run
+   but rather write replacement functions and then change them at run
-	time with png_set_write_fn(...) or png_set_read_fn(...), etc */
+   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
+   writes to a file pointer.  Note that this routine sometimes gets called
-	with very small lengths, so you should implement some kind of simple
+   with very small lengths, so you should implement some kind of simple
-	buffering if you are using unbuffered writes.  This should never be asked
+   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
+   to write more then 64K on a 16 bit machine.  The cast to png_size_t is
-	there to quiet warnings of certain compilers. */
+   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)
+   if (png_ptr->write_data_fn)
-		(*(png_ptr->write_data_fn))(png_ptr, data, length);
+      (*(png_ptr->write_data_fn))(png_ptr, data, length);
-	else
+   else
-		png_error(png_ptr, "Call to NULL write function");
+      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
+   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
+   write_data function and use it at run time with png_set_write_fn(), rather
-	than changing the library. */
+   than changing the library. */
 #ifndef USE_FAR_KEYWORD
 void
 png_default_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
@@ -51,7 +51,7 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
 #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.
+   the data.
 */
 
 #define NEAR_BUF_SIZE 1024
@@ -70,73 +70,73 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
 
    /* Check if data really is near. If so, use usual code. */
 #ifdef _MSC_VER
-	/* do it this way just to quiet warning */
+   /* do it this way just to quiet warning */
    FP_OFF(n_data) = FP_OFF(data);
-	if (FP_SEG(n_data) == FP_SEG(data))
+   if (FP_SEG(n_data) == FP_SEG(data))
 #else
-	/* this works in MSC also but with lost segment warning */
+   /* this works in MSC also but with lost segment warning */
    n_data = (png_byte *)data;
-	if ((png_bytep)n_data == data)
+   if ((png_bytep)n_data == data)
 #endif
    {
       check = fwrite(n_data, 1, (png_size_t)length, png_ptr->fp);
    }
-	else
+   else
    {
       png_byte buf[NEAR_BUF_SIZE];
       png_size_t written, remaining, err;
       check = 0;
       remaining = (png_size_t)length;
-		do
+      do
-		{
+      {
-			written = MIN(NEAR_BUF_SIZE, remaining);
+         written = MIN(NEAR_BUF_SIZE, remaining);
-			png_memcpy(buf, data, written); /* copy far buffer to near buffer */
+         png_memcpy(buf, data, written); /* copy far buffer to near buffer */
          err = fwrite(buf, 1, written, png_ptr->fp);
-			if (err != written)
+         if (err != written)
             break;
-			else
+         else
             check += err;
          data += written;
          remaining -= written;
       }
-		while (remaining != 0);
+      while (remaining != 0);
-	}
+   }
-	if (check != length)
+   if (check != length)
-	{
+   {
-		png_error(png_ptr, "Write Error");
+      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
+   reads from a file pointer.  Note that this routine sometimes gets called
-	with very small lengths, so you should implement some kind of simple
+   with very small lengths, so you should implement some kind of simple
-	buffering if you are using unbuffered reads.  This should never be asked
+   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
+   to read more then 64K on a 16 bit machine.  The cast to png_size_t is
-	there to quiet some compilers */
+   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)
+   if (png_ptr->read_mode == PNG_READ_PUSH_MODE)
-	{
+   {
-   	png_push_fill_buffer(png_ptr, data, length);
+      png_push_fill_buffer(png_ptr, data, length);
-	}
+   }
    else
 #endif
-	{
+   {
-		if (png_ptr->read_data_fn)
+      if (png_ptr->read_data_fn)
-			(*(png_ptr->read_data_fn))(png_ptr, data, length);
+         (*(png_ptr->read_data_fn))(png_ptr, data, length);
-		else
+      else
-			png_error(png_ptr, "Call to NULL read function");
+         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
+   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
+   read_data function and use it at run time with png_set_read_fn(), rather
-	than changing the library. */
+   than changing the library. */
 #ifndef USE_FAR_KEYWORD
 void
 png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
@@ -160,7 +160,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
 #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))
+   if (FP_SEG(n_data) == FP_SEG(data))
 #else
    /* this works in MSC also but with lost segment warning */
    n_data = (png_byte *)data;
@@ -168,7 +168,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
 #endif
    {
       check = fread(n_data, 1, (size_t)length, png_ptr->fp);
-	}
+   }
    else
    {
       png_byte buf[NEAR_BUF_SIZE];
@@ -177,142 +177,142 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_uint_32 length)
       remaining = (png_size_t)length;
       do
       {
-			read = MIN(NEAR_BUF_SIZE, remaining);
+         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 */
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
          if(err != read)
             break;
          else
             check += err;
          data += read;
-			remaining -= read;
+         remaining -= read;
-		}
+      }
-		while (remaining != 0);
+      while (remaining != 0);
-	}
+   }
-	if (check != length)
+   if (check != length)
-	{
+   {
-		png_error(png_ptr, "read Error");
+      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
+   to disk.  After png_flush is called, there should be no data pending
-	writing in any buffers. */
+   writing in any buffers. */
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
 void
 png_flush(png_structp png_ptr)
 {
-	if (png_ptr->output_flush_fn)
+   if (png_ptr->output_flush_fn)
-		(*(png_ptr->output_flush_fn))(png_ptr);
+      (*(png_ptr->output_flush_fn))(png_ptr);
 }
 
 void
 png_default_flush(png_structp png_ptr)
 {
-	if (png_ptr->fp)
+   if (png_ptr->fp)
-		fflush(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.
+   libpng if standard C streams aren't being used.
 
-	This function takes as its arguments:
+   This function takes as its arguments:
-	png_ptr       - pointer to a png output data structure
+   png_ptr       - pointer to a png output data structure
-	io_ptr        - pointer to user supplied structure containing info about
+   io_ptr        - pointer to user supplied structure containing info about
-						 the output functions.  May be NULL.
+                   the output functions.  May be NULL.
-	write_data_fn - pointer to a new output function which takes as its
+   write_data_fn - pointer to a new output function which takes as its
-						 arguments a pointer to a png_struct, a pointer to
+                   arguments a pointer to a png_struct, a pointer to
-						 data to be written, and a 32-bit unsigned int which is
+                   data to be written, and a 32-bit unsigned int which is
-						 the number of bytes to be written.  The new write
+                   the number of bytes to be written.  The new write
-						 function should call png_error(png_ptr, "Error msg")
+                   function should call png_error(png_ptr, "Error msg")
-						 to exit and output any fatal error messages.
+                   to exit and output any fatal error messages.
-	flush_data_fn - pointer to a new flush function which takes as its
+   flush_data_fn - pointer to a new flush function which takes as its
-						 arguments a pointer to a png_struct.  After a call to
+                   arguments a pointer to a png_struct.  After a call to
-						 the flush function, there should be no data in any buffers
+                   the flush function, there should be no data in any buffers
-						 or pending transmission.  If the output method doesn't do
+                   or pending transmission.  If the output method doesn't do
-						 any buffering of ouput, a function prototype must still be
+                   any buffering of ouput, a function prototype must still be
-						 supplied although it doesn't have to do anything.  If
+                   supplied although it doesn't have to do anything.  If
-						 PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
+                   PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
-						 time, output_flush_fn will be ignored, although it must be
+                   time, output_flush_fn will be ignored, although it must be
-						 supplied for compatibility. */
+                   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_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
 {
-	png_ptr->io_ptr = io_ptr;
+   png_ptr->io_ptr = io_ptr;
 
-	if (write_data_fn)
+   if (write_data_fn)
-		png_ptr->write_data_fn = write_data_fn;
+      png_ptr->write_data_fn = write_data_fn;
-	else
+   else
-		png_ptr->write_data_fn = png_default_write_data;
+      png_ptr->write_data_fn = png_default_write_data;
 
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
-	if (output_flush_fn)
+   if (output_flush_fn)
-		png_ptr->output_flush_fn = output_flush_fn;
+      png_ptr->output_flush_fn = output_flush_fn;
-	else
+   else
-		png_ptr->output_flush_fn = png_default_flush;
+      png_ptr->output_flush_fn = png_default_flush;
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 
-	/* It is an error to read while writing a png file */
+   /* It is an error to read while writing a png file */
-	png_ptr->read_data_fn = NULL;
+   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.
+   for libpng if standard C streams aren't being used.
 
-	This function takes as its arguments:
+   This function takes as its arguments:
-	png_ptr      - pointer to a png input data structure
+   png_ptr      - pointer to a png input data structure
-	io_ptr       - pointer to user supplied structure containing info about
+   io_ptr       - pointer to user supplied structure containing info about
-						the input functions.  May be NULL.
+                  the input functions.  May be NULL.
-	read_data_fn - pointer to a new input function which takes as it's
+   read_data_fn - pointer to a new input function which takes as it's
-						arguments a pointer to a png_struct, a pointer to
+                  arguments a pointer to a png_struct, a pointer to
-						a location where input data can be stored, and a 32-bit
+                  a location where input data can be stored, and a 32-bit
-						unsigned int which is the number of bytes to be read.
+                  unsigned int which is the number of bytes to be read.
-						To exit and output any fatal error messages the new write
+                  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_rw_ptr read_data_fn)
 {
-	png_ptr->io_ptr = io_ptr;
+   png_ptr->io_ptr = io_ptr;
 
-	if (read_data_fn)
+   if (read_data_fn)
-		png_ptr->read_data_fn = read_data_fn;
+      png_ptr->read_data_fn = read_data_fn;
-	else
+   else
-		png_ptr->read_data_fn = png_default_read_data;
+      png_ptr->read_data_fn = png_default_read_data;
 
-	/* It is an error to write to a read device */
+   /* It is an error to write to a read device */
-	png_ptr->write_data_fn = NULL;
+   png_ptr->write_data_fn = NULL;
 
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
-	png_ptr->output_flush_fn = NULL;
+   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
+   functions.  The application should free any memory associated with this
-	pointer before png_write_destroy and png_read_destroy are called. */
+   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;
+   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()
+   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->fp = fp;
-	png_ptr->read_data_fn = png_default_read_data;
+   png_ptr->read_data_fn = png_default_read_data;
-	png_ptr->write_data_fn = png_default_write_data;
+   png_ptr->write_data_fn = png_default_write_data;
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
-	png_ptr->output_flush_fn = png_default_flush;
+   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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 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
+   need special memory handling are expected to modify the code in this file
-	to meet their needs.  See the instructions at each function. */
+   to meet their needs.  See the instructions at each function. */
 
 #define PNG_INTERNAL
 #include "png.h"
@@ -18,190 +18,113 @@
 /* if you change this, be sure to change the one in png.h also */
 
 /* Allocate memory.  For reasonable files, size should never exceed
-	64K.  However, zlib may allocate more then 64K if you don't tell
+   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
+   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
+   need to allocate exactly 64K, so whatever you call here must
-	have the ability to do that. */
+   have the ability to do that. */
 
 /* Borland seems to have a problem in DOS mode for exactly 64K.
-	It gives you a segment with an offset of 8 (perhaps to store it's
+   It gives you a segment with an offset of 8 (perhaps to store it's
-	memory stuff).  zlib doesn't like this at all, so we have to
+   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
+   detect and deal with it.  This code should not be needed in
    Windows or OS/2 modes, and only in 16 bit mode.
 */
 
 png_voidp
 png_large_malloc(png_structp png_ptr, png_uint_32 size)
 {
-	png_voidp ret;
+   png_voidp ret;
-	if (!png_ptr || !size)
+   if (!png_ptr || !size)
-		return ((voidp)0);
+      return ((voidp)0);
 
 #ifdef PNG_MAX_MALLOC_64K
-	if (size > (png_uint_32)65536L)
+   if (size > (png_uint_32)65536L)
-		png_error(png_ptr, "Cannot Allocate > 64K");
+      png_error(png_ptr, "Cannot Allocate > 64K");
 #endif
 
-	if (size == (png_uint_32)(65536L))
+   if (size == (png_uint_32)(65536L))
-	{
+   {
-		if (!png_ptr->offset_table)
+      if (!png_ptr->offset_table)
-		{
+      {
-			/* try to see if we need to do any of this fancy stuff */
+         /* try to see if we need to do any of this fancy stuff */
-			ret = farmalloc(size);
+         ret = farmalloc(size);
-			if (!ret || ((long)ret & 0xffff))
+         if (!ret || ((long)ret & 0xffff))
-			{
+         {
-				int num_blocks;
+            int num_blocks;
-				png_uint_32 total_size;
+            png_uint_32 total_size;
-				png_bytep table;
+            png_bytep table;
-				int i;
+            int i;
             png_byte huge * hptr;
 
-				if (ret)
+            if (ret)
-					farfree(ret);
+               farfree(ret);
-				ret = 0;
+            ret = 0;
 
-				num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
+            num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
-				if (num_blocks < 1)
+            if (num_blocks < 1)
-					num_blocks = 1;
+               num_blocks = 1;
-				if (png_ptr->zlib_mem_level >= 7)
+            if (png_ptr->zlib_mem_level >= 7)
-					num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
+               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
-				else
+            else
-            	num_blocks++;
+               num_blocks++;
 
-				total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks;
+            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks;
 
-				table = farmalloc(total_size);
+            table = farmalloc(total_size);
 
-				if (!table)
+            if (!table)
-				{
+            {
-					png_error(png_ptr, "Out of Memory");
+               png_error(png_ptr, "Out of Memory");
-				}
+            }
 
-				if ((long)table & 0xffff)
+            if ((long)table & 0xffff)
-				{
+            {
-					farfree(table);
+               farfree(table);
-					total_size += (png_uint_32)65536L;
+               total_size += (png_uint_32)65536L;
-				}
+            }
 
-				table = farmalloc(total_size);
+            table = farmalloc(total_size);
 
-				if (!table)
+            if (!table)
-				{
+            {
-					png_error(png_ptr, "Out of Memory");
+               png_error(png_ptr, "Out of Memory");
-				}
+            }
 
-				png_ptr->offset_table = table;
+            png_ptr->offset_table = table;
-				png_ptr->offset_table_ptr = farmalloc(
+            png_ptr->offset_table_ptr = farmalloc(
-					num_blocks * sizeof (png_bytep));
+               num_blocks * sizeof (png_bytep));
-				hptr = (png_byte huge *)table;
+            hptr = (png_byte huge *)table;
-				if ((long)hptr & 0xffff)
+            if ((long)hptr & 0xffff)
-				{
+            {
-					hptr = (png_byte huge *)((long)(hptr) & 0xffff0000L);
+               hptr = (png_byte huge *)((long)(hptr) & 0xffff0000L);
-					hptr += 65536L;
+               hptr += 65536L;
-				}
+            }
-				for (i = 0; i < num_blocks; i++)
+            for (i = 0; i < num_blocks; i++)
-				{
+            {
-					png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
-					hptr += 65536L;
+               hptr += 65536L;
-				}
+            }
 
-				png_ptr->offset_table_number = num_blocks;
+            png_ptr->offset_table_number = num_blocks;
-				png_ptr->offset_table_count = 0;
+            png_ptr->offset_table_count = 0;
-				png_ptr->offset_table_count_free = 0;
+            png_ptr->offset_table_count_free = 0;
-			}
+         }
 
-			if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
+         if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
-				png_error(png_ptr, "Out of Memory");
+            png_error(png_ptr, "Out of Memory");
 
          ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
-		}
+      }
-	}
+   }
-	else
+   else
-		ret = farmalloc(size);
+      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])
-            {
-					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 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;
+   return ret;
 }
 
 /* free a pointer allocated by png_large_malloc().  In the default
@@ -211,29 +134,106 @@ 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 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
+   should not get anywhere near 64K.  On segmented machines, this
-	must come from the local heap (for zlib).  Currently, zlib is
+   must come from the local heap (for zlib).  Currently, zlib is
-	the only one that uses this, so you should only get one call
+   the only one that uses this, so you should only get one call
-	to this, and that a small block. */
+   to this, and that a small block. */
 void *
 png_malloc(png_structp png_ptr, png_uint_32 size)
 {
@@ -252,39 +252,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
+   even marginally reasonable file.  This is not used in
-	the current version of the library. */
+   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)
+   if (!png_ptr || !old_size || !ptr || !size)
-		return ((void *)0);
+      return ((void *)0);
 
 #ifdef PNG_MAX_MALLOC_64K
-	if (size > (png_uint_32)65536L)
+   if (size > (png_uint_32)65536L)
-		png_error(png_ptr, "Cannot Allocate > 64K");
+      png_error(png_ptr, "Cannot Allocate > 64K");
 #endif
 
-	ret = realloc(ptr, (png_size_t)size);
+   ret = realloc(ptr, (png_size_t)size);
 
-	if (!ret)
+   if (!ret)
-	{
+   {
-		png_error(png_ptr, "Out of Memory 7");
+      png_error(png_ptr, "Out of Memory 7");
-	}
+   }
 
-	return ret;
+   return ret;
 }
 
 /* free a pointer allocated by png_malloc().  In the default
@@ -293,11 +293,11 @@ png_realloc(png_structp png_ptr, void * ptr, png_uint_32 size,
 void
 png_free(png_structp png_ptr, void * ptr)
 {
-	if (!png_ptr)
+   if (!png_ptr)
-		return;
+      return;
 
-	if (ptr != (void *)0)
+   if (ptr != (void *)0)
-		free(ptr);
+      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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 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->bit_depth = (png_byte)bit_depth;
-	info->color_type =(png_byte) color_type;
+   info->color_type =(png_byte) color_type;
-	info->compression_type = (png_byte)compression_type;
+   info->compression_type = (png_byte)compression_type;
-	info->filter_type = (png_byte)filter_type;
+   info->filter_type = (png_byte)filter_type;
-	info->interlace_type = (png_byte)interlace_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 white_x, double white_y, double red_x, double red_y,
-	double green_x, double green_y, double blue_x, double blue_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;
@@ -193,24 +193,24 @@ 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;
+         info->max_text = info->num_text + 16;
-			{
+         {
-				png_textp old_text;
+            png_textp old_text;
 
-				old_text = info->text;
+            old_text = info->text;
-				info->text = (png_textp)png_large_malloc(png_ptr,
+            info->text = (png_textp)png_large_malloc(png_ptr,
-					info->max_text * sizeof (png_text));
+               info->max_text * sizeof (png_text));
-				png_memcpy(info->text, old_text,
+            png_memcpy(info->text, old_text,
-					(png_size_t)(old_max * sizeof (png_text)));
+               (png_size_t)(old_max * sizeof (png_text)));
-				png_large_free(png_ptr, old_text);
+            png_large_free(png_ptr, old_text);
-			}
+         }
       }
       else
       {
@@ -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,10 +1,10 @@
 
 /* pngread.c - read a png file
 
-   libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
    Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 25, 1996
    */
 
 #define PNG_INTERNAL

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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 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) +
+   i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
-		(png_uint_16)(*(buf + 1)));
+      (png_uint_16)(*(buf + 1)));
 
    return i;
 }
@@ -99,7 +99,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info, png_uint_32 length)
       color_type == 5 || color_type > 6)
       png_error(png_ptr, "Invalid Color Type Found");
 
-	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");
 
@@ -121,9 +121,9 @@ png_handle_IHDR(png_structp png_ptr, png_infop info, png_uint_32 length)
    /* set internal variables */
    png_ptr->width = width;
    png_ptr->height = height;
-	png_ptr->bit_depth = (png_byte)bit_depth;
+   png_ptr->bit_depth = (png_byte)bit_depth;
-	png_ptr->interlaced = (png_byte)interlace_type;
+   png_ptr->interlaced = (png_byte)interlace_type;
-	png_ptr->color_type = (png_byte)color_type;
+   png_ptr->color_type = (png_byte)color_type;
 
    /* find number of channels */
    switch (png_ptr->color_type)
@@ -143,8 +143,8 @@ 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->pixel_depth = (png_byte)(png_ptr->bit_depth *
-		png_ptr->channels);
+      png_ptr->channels);
    png_ptr->rowbytes = ((png_ptr->width *
       (png_uint_32)png_ptr->pixel_depth + 7) >> 3);
    /* call the IHDR callback (which should just set up info) */
@@ -165,7 +165,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info, png_uint_32 length)
    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,7 +176,7 @@ 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);
 }
 
@@ -191,7 +191,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info, png_uint_32 length)
    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 +199,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 +212,20 @@ 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->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);
+      png_crc_skip(png_ptr, length);
-		return;
+      return;
    }
 
    png_crc_read(png_ptr, buf, length);
@@ -238,7 +238,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));
@@ -256,8 +256,8 @@ png_handle_cHRM(png_structp png_ptr, png_infop info, png_uint_32 length)
    if (length != 32)
    {
       png_warning(png_ptr, "Incorrect cHRM chunk length");
-		png_crc_skip(png_ptr, length);
+      png_crc_skip(png_ptr, length);
-		return;
+      return;
    }
 
    png_crc_read(png_ptr, buf, 4);
@@ -293,7 +293,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
 
@@ -306,14 +306,14 @@ png_handle_tRNS(png_structp png_ptr, png_infop info, png_uint_32 length)
       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_crc_read(png_ptr, png_ptr->trans, length);
-		png_ptr->num_trans = (png_uint_16)length;
+      png_ptr->num_trans = (png_uint_16)length;
    }
    else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
    {
@@ -322,7 +322,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,15 +339,15 @@ 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);
+         png_crc_skip(png_ptr, length);
-			return;
+         return;
-		}
+      }
 
-		png_crc_read(png_ptr, buf, 2);
+      png_crc_read(png_ptr, buf, 2);
-		png_ptr->num_trans = 1;
+      png_ptr->num_trans = 1;
-		png_ptr->trans_values.gray = png_get_uint_16(buf);
+      png_ptr->trans_values.gray = png_get_uint_16(buf);
-	}
+   }
-	else
+   else
       png_warning(png_ptr, "Invalid tRNS chunk");
 
    png_read_tRNS(png_ptr, info, png_ptr->trans, png_ptr->num_trans,
@@ -371,8 +371,8 @@ 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_warning(png_ptr, "Incorrect bKGD chunk length");
-		png_crc_skip(png_ptr, length);
+      png_crc_skip(png_ptr, length);
       return;
    }
 
@@ -396,20 +396,20 @@ 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)
+   if (length != 2 * png_ptr->num_palette)
-	{
+   {
-		png_warning(png_ptr, "Incorrect hIST chunk length");
+      png_warning(png_ptr, "Incorrect hIST chunk length");
-		png_crc_skip(png_ptr, length);
+      png_crc_skip(png_ptr, length);
-		return;
+      return;
-	}
+   }
 
    num = (int)length / 2;
-	png_ptr->hist = (png_uint_16p)png_large_malloc(png_ptr,
+   png_ptr->hist = (png_uint_16p)png_large_malloc(png_ptr,
-		num * sizeof (png_uint_16));
+      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];
 
@@ -430,10 +430,10 @@ png_handle_pHYs(png_structp png_ptr, png_infop info, png_uint_32 length)
 
    if (length != 9)
    {
-		png_warning(png_ptr, "Incorrect pHYs chunk length");
+      png_warning(png_ptr, "Incorrect pHYs chunk length");
-		png_crc_skip(png_ptr, length);
+      png_crc_skip(png_ptr, length);
       return;
-	}
+   }
 
    png_crc_read(png_ptr, buf, 9);
 
@@ -454,12 +454,12 @@ png_handle_oFFs(png_structp png_ptr, png_infop info, png_uint_32 length)
 
    if (length != 9)
    {
-		png_warning(png_ptr, "Incorrect oFFs chunk length");
+      png_warning(png_ptr, "Incorrect oFFs chunk length");
-		png_crc_skip(png_ptr, 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);
@@ -477,8 +477,8 @@ png_handle_tIME(png_structp png_ptr, png_infop info, png_uint_32 length)
 
    if (length != 7)
    {
-		png_warning(png_ptr, "Incorrect tIME chunk length");
+      png_warning(png_ptr, "Incorrect tIME chunk length");
-		png_crc_skip(png_ptr, length);
+      png_crc_skip(png_ptr, length);
       return;
    }
 
@@ -489,7 +489,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,12 +500,12 @@ 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);
+   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 */ ;
@@ -527,8 +527,8 @@ png_handle_zTXt(png_structp png_ptr, png_infop info, png_uint_32 length)
    int ret;
    png_uint_32 text_size, key_size;
 
-	key = png_large_malloc(png_ptr, length + 1);
+   key = png_large_malloc(png_ptr, length + 1);
-	png_crc_read(png_ptr, (png_bytep )key, length);
+   png_crc_read(png_ptr, (png_bytep )key, length);
    key[(png_size_t)length] = '\0';
 
    for (text = key; *text; text++)
@@ -538,7 +538,7 @@ 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);
+      png_large_free(png_ptr, key);
       return;
    }
 
@@ -559,19 +559,19 @@ png_handle_zTXt(png_structp png_ptr, png_infop info, png_uint_32 length)
 
    key_size = text - key;
    text_size = 0;
-	text = NULL;
+   text = NULL;
    ret = Z_STREAM_END;
 
    while (png_ptr->zstream->avail_in)
    {
-		ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
+      ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
       if (ret != Z_OK && ret != Z_STREAM_END)
       {
-			if (png_ptr->zstream->msg)
+         if (png_ptr->zstream->msg)
-				png_warning(png_ptr, png_ptr->zstream->msg);
+            png_warning(png_ptr, png_ptr->zstream->msg);
          else
-				png_warning(png_ptr, "zTXt decompression error");
+            png_warning(png_ptr, "zTXt decompression error");
-			inflateReset(png_ptr->zstream);
+         inflateReset(png_ptr->zstream);
          png_ptr->zstream->avail_in = 0;
          png_large_free(png_ptr, key);
          png_large_free(png_ptr, text);
@@ -593,7 +593,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info, png_uint_32 length)
          }
          else
          {
-				png_charp tmp;
+            png_charp tmp;
 
             tmp = text;
             text = png_large_malloc(png_ptr, text_size +
@@ -620,7 +620,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info, png_uint_32 length)
          break;
    }
 
-	inflateReset(png_ptr->zstream);
+   inflateReset(png_ptr->zstream);
    png_ptr->zstream->avail_in = 0;
 
    if (ret != Z_STREAM_END)
@@ -683,7 +683,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 +721,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 +758,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 +835,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 +871,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 +908,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);
@@ -1145,7 +1145,7 @@ 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 ||
@@ -1279,11 +1279,11 @@ png_read_start_row(png_structp png_ptr)
    if (rowbytes > 65536L)
       png_error(png_ptr, "This image requires a row greater then 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 then 64KB");
 #endif
    png_ptr->prev_row = png_large_malloc(png_ptr,
       png_ptr->rowbytes + 1);

pngtest.c

@@ -1,8 +1,8 @@
 /* pngtest.c - a simple test program to test libpng
 
-	libpng 1.0 beta 2 - version 0.87
+   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.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
    January 15, 1996
 */
 
@@ -16,7 +16,7 @@
 
 /* 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";
@@ -32,13 +32,13 @@ char inbuf[256], outbuf[256];
 int main()
 {
    FILE *fpin, *fpout;
-	png_bytep row_buf;
+   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;
+   row_buf = (png_bytep)0;
    near_row_buf = (png_byte *)0;
 
    fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
@@ -75,7 +75,7 @@ int main()
    }
 
    if (setjmp(write_ptr.jmpbuf))
-	{
+   {
       fprintf(STDERR, "libpng write error\n");
       fclose(fpin);
       fclose(fpout);
@@ -93,7 +93,7 @@ int main()
    png_read_info(&read_ptr, &info_ptr);
    png_write_info(&write_ptr, &info_ptr);
 
-	if ((info_ptr.color_type & 3) == 2)
+   if ((info_ptr.color_type & 3) == 2)
       channels = 3;
    else
       channels = 1;
@@ -101,7 +101,7 @@ int main()
       channels++;
 
    rowbytes = ((info_ptr.width * info_ptr.bit_depth * channels + 7) >> 3);
-	near_row_buf = (png_byte *)malloc((size_t)rowbytes);
+   near_row_buf = (png_byte *)malloc((size_t)rowbytes);
    row_buf = (png_bytep)near_row_buf;
    if (!row_buf)
    {
@@ -130,8 +130,8 @@ int main()
 #ifdef TESTING
          fprintf(STDERR, "Processing line #%ld\n", y);
 #endif
-			png_read_rows(&read_ptr, (png_bytepp)&row_buf, (png_bytepp)0, 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_write_rows(&write_ptr, (png_bytepp)&row_buf, 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
+   optional palette creation
-	histogram creation
+   histogram creation
-	text conversion between different code types
+   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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 25, 1996
    */
 
 #define PNG_INTERNAL
@@ -199,7 +199,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;
 

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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 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. */
@@ -88,7 +88,7 @@ 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);
@@ -99,7 +99,7 @@ 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);
 #endif
          }
       }
@@ -114,7 +114,7 @@ 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 */
+   /* see if user wants us to write information chunks */
    if (info)
    {
 #if defined(PNG_WRITE_tIME_SUPPORTED)
@@ -130,7 +130,7 @@ png_write_end(png_structp png_ptr, png_infop info)
 
          /* loop through comment chunks */
          for (i = 0; i < info->num_text; i++)
-			{
+         {
             /* check to see if comment is to be compressed */
             if (info->text[i].compression >= 0)
             {
@@ -148,7 +148,7 @@ png_write_end(png_structp png_ptr, png_infop info)
                png_write_tEXt(png_ptr, info->text[i].key,
                   info->text[i].text, info->text[i].text_length);
 #endif
-				}
+            }
          }
       }
 #endif
@@ -161,12 +161,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->year = (png_uint_16)(1900 + ttime->tm_year);
-	ptime->month = (png_byte)(ttime->tm_mon + 1);
+   ptime->month = (png_byte)(ttime->tm_mon + 1);
-	ptime->day = (png_byte)ttime->tm_mday;
+   ptime->day = (png_byte)ttime->tm_mday;
-	ptime->hour = (png_byte)ttime->tm_hour;
+   ptime->hour = (png_byte)ttime->tm_hour;
-	ptime->minute = (png_byte)ttime->tm_min;
+   ptime->minute = (png_byte)ttime->tm_min;
-	ptime->second = (png_byte)ttime->tm_sec;
+   ptime->second = (png_byte)ttime->tm_sec;
 }
 
 void
@@ -184,23 +184,23 @@ void
 png_write_init(png_structp png_ptr)
 {
    jmp_buf tmp_jmp; /* to save current jump buffer */
-	png_msg_ptr error_fn;
+   png_msg_ptr error_fn;
-	png_msg_ptr warning_fn;
+   png_msg_ptr warning_fn;
-	png_voidp msg_ptr;
+   png_voidp msg_ptr;
 
-	/* save jump buffer and error functions */
+   /* save jump buffer and error functions */
-	png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
-	error_fn = png_ptr->error_fn;
+   error_fn = png_ptr->error_fn;
-	warning_fn = png_ptr->warning_fn;
+   warning_fn = png_ptr->warning_fn;
-	msg_ptr = png_ptr->msg_ptr;
+   msg_ptr = png_ptr->msg_ptr;
 
-	/* reset all variables to 0 */
+   /* reset all variables to 0 */
-	png_memset(png_ptr, 0, sizeof (png_struct));
+   png_memset(png_ptr, 0, sizeof (png_struct));
-	/* restore jump buffer and error functions */
+   /* restore jump buffer and error functions */
    png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
-	png_ptr->error_fn = error_fn;
+   png_ptr->error_fn = error_fn;
-	png_ptr->warning_fn = warning_fn;
+   png_ptr->warning_fn = warning_fn;
-	png_ptr->msg_ptr = msg_ptr;
+   png_ptr->msg_ptr = msg_ptr;
 
    /* initialize zbuf - compression buffer */
    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
@@ -210,7 +210,7 @@ png_write_init(png_structp png_ptr)
 /* 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)
@@ -264,7 +264,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 +282,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 +300,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 +318,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.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
-		png_ptr->row_info.channels);
+      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 +336,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))
       {
@@ -354,7 +354,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
    if (png_ptr->do_filter)
    {
       /* save row to previous row */
-		png_memcpy(png_ptr->save_row, png_ptr->row_buf,
+      png_memcpy(png_ptr->save_row, png_ptr->row_buf,
          (png_size_t)png_ptr->row_info.rowbytes + 1);
 
       /* filter row */
@@ -363,7 +363,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
 
       /* trade saved pointer and prev pointer so next row references are correctly */
       { /* scope limiter */
-			png_bytep tptr;
+         png_bytep tptr;
 
          tptr = png_ptr->prev_row;
          png_ptr->prev_row = png_ptr->save_row;
@@ -372,7 +372,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
    }
    else
       /* set filter row to "none" */
-		png_ptr->row_buf[0] = 0;
+      png_ptr->row_buf[0] = 0;
 
    /* set up the zlib input buffer */
    png_ptr->zstream->next_in = png_ptr->row_buf;
@@ -389,8 +389,8 @@ png_write_row(png_structp png_ptr, png_bytep row)
       {
          if (png_ptr->zstream->msg)
             png_error(png_ptr, png_ptr->zstream->msg);
-			else
+         else
-				png_error(png_ptr, "zlib error");
+            png_error(png_ptr, "zlib error");
       }
 
       /* see if it is time to write another IDAT */
@@ -404,17 +404,17 @@ png_write_row(png_structp png_ptr, png_bytep row)
    /* repeat until all data has been compressed */
    } while (png_ptr->zstream->avail_in);
 
-	/* finish row - updates counters and flushes zlib if last row */
+   /* finish row - updates counters and flushes zlib if last row */
-	png_write_finish_row(png_ptr);
+   png_write_finish_row(png_ptr);
 
 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
-	png_ptr->flush_rows++;
+   png_ptr->flush_rows++;
 
-	if (png_ptr->flush_dist > 0 &&
+   if (png_ptr->flush_dist > 0 &&
-		 png_ptr->flush_rows >= png_ptr->flush_dist)
+       png_ptr->flush_rows >= png_ptr->flush_dist)
-	{
+   {
-		png_write_flush(png_ptr);
+      png_write_flush(png_ptr);
-	}
+   }
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 }
 
@@ -423,57 +423,57 @@ 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)
+   if (png_ptr->mode != PNG_HAVE_IDAT)
-	  return;
+     return;
 
-	do
+   do
-	{
+   {
-		int ret;
+      int ret;
 
-		/* compress the data */
+      /* compress the data */
-		ret = deflate(png_ptr->zstream, Z_SYNC_FLUSH);
+      ret = deflate(png_ptr->zstream, Z_SYNC_FLUSH);
-		wrote_IDAT = 0;
+      wrote_IDAT = 0;
 
-		/* check for compression errors */
+      /* check for compression errors */
-		if (ret != Z_OK)
+      if (ret != Z_OK)
-		{
+      {
-			if (png_ptr->zstream->msg)
+         if (png_ptr->zstream->msg)
-				png_error(png_ptr, png_ptr->zstream->msg);
+            png_error(png_ptr, png_ptr->zstream->msg);
-			else
+         else
-				png_error(png_ptr, "zlib error");
+            png_error(png_ptr, "zlib error");
-		}
+      }
 
-		if (!png_ptr->zstream->avail_out)
+      if (!png_ptr->zstream->avail_out)
-		{
+      {
-			/* write the IDAT and reset the zlib output buffer */
+         /* write the IDAT and reset the zlib output buffer */
-			png_write_IDAT(png_ptr, png_ptr->zbuf,
+         png_write_IDAT(png_ptr, png_ptr->zbuf,
-								png_ptr->zbuf_size);
+                        png_ptr->zbuf_size);
-			png_ptr->zstream->next_out = png_ptr->zbuf;
+         png_ptr->zstream->next_out = png_ptr->zbuf;
-			png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
+         png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
-			wrote_IDAT = 1;
+         wrote_IDAT = 1;
-		}
+      }
-	} while(wrote_IDAT == 1);
+   } while(wrote_IDAT == 1);
 
-	/* If there is any data left to be output, write it into a new IDAT */
+   /* 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)
+   if (png_ptr->zbuf_size != png_ptr->zstream->avail_out)
-	{
+   {
-		/* write the IDAT and reset the zlib output buffer */
+      /* write the IDAT and reset the zlib output buffer */
-		png_write_IDAT(png_ptr, png_ptr->zbuf,
+      png_write_IDAT(png_ptr, png_ptr->zbuf,
-							png_ptr->zbuf_size - png_ptr->zstream->avail_out);
+                     png_ptr->zbuf_size - png_ptr->zstream->avail_out);
-		png_ptr->zstream->next_out = png_ptr->zbuf;
+      png_ptr->zstream->next_out = png_ptr->zbuf;
-		png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
+      png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
-	}
+   }
-	png_ptr->flush_rows = 0;
+   png_ptr->flush_rows = 0;
-	png_flush(png_ptr);
+   png_flush(png_ptr);
 }
 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 
@@ -482,10 +482,10 @@ png_write_flush(png_structp png_ptr)
 void
 png_write_destroy(png_structp png_ptr)
 {
-	jmp_buf tmp_jmp; /* save jump buffer */
+   jmp_buf tmp_jmp; /* save jump buffer */
 
    /* 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);
@@ -515,7 +515,7 @@ 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->zlib_mem_level = mem_level;
 }
 
 void

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 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 25, 1996
    */
 
 #define PNG_INTERNAL
@@ -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;
+            int mask;
-				png_int_32 i;
+            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 = (png_byte)v;
-						dp++;
+                  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) +
+               v = (png_uint_16)(((png_uint_16)(*bp) << 8) +
-						(png_uint_16)(*(bp + 1)));
+                  (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);
             }
          }
@@ -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;

pngwutil.c

@@ -1,10 +1,10 @@
 
 /* pngwutil.c - utilities to write a png file
 
-	libpng 1.0 beta 2 - version 0.87
+   libpng 1.0 beta 2 - version 0.88
    For conditions of distribution and use, see copyright notice in png.h
-	Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 15, 1996
+   January 25, 1996
    */
 #define PNG_INTERNAL
 #include "png.h"
@@ -142,15 +142,15 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
    /* pack the header information into the buffer */
    png_save_uint_32(buf, width);
    png_save_uint_32(buf + 4, height);
-	buf[8] = (png_byte)bit_depth;
+   buf[8] = (png_byte)bit_depth;
-	buf[9] = (png_byte)color_type;
+   buf[9] = (png_byte)color_type;
-	buf[10] = (png_byte)compression_type;
+   buf[10] = (png_byte)compression_type;
-	buf[11] = (png_byte)filter_type;
+   buf[11] = (png_byte)filter_type;
-	buf[12] = (png_byte)interlace_type;
+   buf[12] = (png_byte)interlace_type;
-	/* save off the relevent information */
+   /* save off the relevent information */
-	png_ptr->bit_depth = (png_byte)bit_depth;
+   png_ptr->bit_depth = (png_byte)bit_depth;
-	png_ptr->color_type = (png_byte)color_type;
+   png_ptr->color_type = (png_byte)color_type;
-	png_ptr->interlaced = (png_byte)interlace_type;
+   png_ptr->interlaced = (png_byte)interlace_type;
    png_ptr->width = width;
    png_ptr->height = height;
 
@@ -170,7 +170,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
          png_ptr->channels = 4;
          break;
    }
-	png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
+   png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
    png_ptr->rowbytes = ((width * (png_uint_32)png_ptr->pixel_depth + 7) >> 3);
    /* set the usr info, so any transformations can modify it */
    png_ptr->usr_width = png_ptr->width;
@@ -224,7 +224,7 @@ void
 png_write_PLTE(png_structp png_ptr, png_colorp palette, int number)
 {
    int i;
-	png_colorp pal_ptr;
+   png_colorp pal_ptr;
    png_byte buf[3];
 
    png_write_chunk_start(png_ptr, png_PLTE, number * 3);
@@ -304,8 +304,8 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
 /* write the cHRM chunk */
 void
 png_write_cHRM ( png_structp png_ptr, double white_x, double white_y,
-	double red_x, double red_y, double green_x, double green_y,
+   double red_x, double red_y, double green_x, double green_y,
-	double blue_x, double blue_y)
+   double blue_x, double blue_y)
 {
    png_uint_32 itemp;
    png_byte buf[32];
@@ -381,7 +381,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
       png_write_chunk(png_ptr, png_bKGD, buf, (png_uint_32)6);
    }
    else
-	{
+   {
       png_save_uint_16(buf, back->gray);
       png_write_chunk(png_ptr, png_bKGD, buf, (png_uint_32)2);
    }
@@ -399,7 +399,7 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int number)
    png_write_chunk_start(png_ptr, png_hIST, (png_uint_32)(number * 2));
    for (i = 0; i < number; i++)
    {
-		png_save_uint_16(buf, hist[i]);
+      png_save_uint_16(buf, hist[i]);
       png_write_chunk_data(png_ptr, buf, (png_uint_32)2);
    }
    png_write_chunk_end(png_ptr);
@@ -417,7 +417,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
    key_len = png_strlen(key);
    /* make sure we count the 0 after the key */
    png_write_chunk_start(png_ptr, png_tEXt,
-		(png_uint_32)(key_len + text_len + 1));
+      (png_uint_32)(key_len + text_len + 1));
    /* key has an 0 at the end.  How nice */
    png_write_chunk_data(png_ptr, (png_bytep )key, (png_uint_32)(key_len + 1));
    if (text && text_len)
@@ -435,7 +435,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
    int key_len;
    char buf[1];
    int i, ret;
-	png_charpp output_ptr = NULL; /* array of pointers to output */
+   png_charpp output_ptr = NULL; /* array of pointers to output */
    int num_output_ptr = 0; /* number of output pointers used */
    int max_output_ptr = 0; /* size of output_ptr */
 
@@ -453,11 +453,11 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
    png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
    png_ptr->zstream->next_out = (Bytef *)png_ptr->zbuf;
 
-	/* this is the same compression loop as in png_write_row() */
+   /* this is the same compression loop as in png_write_row() */
    do
    {
       /* compress the data */
-		ret = deflate(png_ptr->zstream, Z_NO_FLUSH);
+      ret = deflate(png_ptr->zstream, Z_NO_FLUSH);
       if (ret != Z_OK)
       {
          /* error */
@@ -471,25 +471,25 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
       {
          /* make sure the output array has room */
          if (num_output_ptr >= max_output_ptr)
-			{
+         {
             png_uint_32 old_max;
 
             old_max = max_output_ptr;
             max_output_ptr = num_output_ptr + 4;
-				if (output_ptr)
+            if (output_ptr)
-				{
+            {
-					png_charpp old_ptr;
+               png_charpp old_ptr;
 
-					old_ptr = output_ptr;
+               old_ptr = output_ptr;
-					output_ptr = (png_charpp)png_large_malloc(png_ptr,
+               output_ptr = (png_charpp)png_large_malloc(png_ptr,
-						max_output_ptr * sizeof (png_charpp));
+                  max_output_ptr * sizeof (png_charpp));
-					png_memcpy(output_ptr, old_ptr,
+               png_memcpy(output_ptr, old_ptr,
-						(png_size_t)(old_max * sizeof (png_charp)));
+                  (png_size_t)(old_max * sizeof (png_charp)));
-					png_large_free(png_ptr, old_ptr);
+               png_large_free(png_ptr, old_ptr);
-				}
+            }
-				else
+            else
-					output_ptr = (png_charpp)png_large_malloc(png_ptr,
+               output_ptr = (png_charpp)png_large_malloc(png_ptr,
-						max_output_ptr * sizeof (png_charp));
+                  max_output_ptr * sizeof (png_charp));
          }
 
          /* save the data */
@@ -506,11 +506,11 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
    /* continue until we don't have anymore to compress */
    } while (png_ptr->zstream->avail_in);
 
-	/* finish the compression */
+   /* finish the compression */
    do
    {
       /* tell zlib we are finished */
-		ret = deflate(png_ptr->zstream, Z_FINISH);
+      ret = deflate(png_ptr->zstream, Z_FINISH);
       if (ret != Z_OK && ret != Z_STREAM_END)
       {
          /* we got an error */
@@ -523,33 +523,33 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
       /* check to see if we need more room */
       if (!png_ptr->zstream->avail_out && ret == Z_OK)
       {
-			/* check to make sure our output array has room */
+         /* check to make sure our output array has room */
-			if (num_output_ptr >= max_output_ptr)
+         if (num_output_ptr >= max_output_ptr)
          {
             png_uint_32 old_max;
 
             old_max = max_output_ptr;
             max_output_ptr = num_output_ptr + 4;
             if (output_ptr)
-				{
+            {
-					png_charpp old_ptr;
+               png_charpp old_ptr;
 
-					old_ptr = output_ptr;
+               old_ptr = output_ptr;
-					output_ptr = (png_charpp)png_large_malloc(png_ptr,
+               output_ptr = (png_charpp)png_large_malloc(png_ptr,
-						max_output_ptr * sizeof (png_charpp));
+                  max_output_ptr * sizeof (png_charpp));
-					png_memcpy(output_ptr, old_ptr,
+               png_memcpy(output_ptr, old_ptr,
-						(png_size_t)(old_max * sizeof (png_charp)));
+                  (png_size_t)(old_max * sizeof (png_charp)));
-					png_large_free(png_ptr, old_ptr);
+               png_large_free(png_ptr, old_ptr);
-				}
+            }
-				else
+            else
-					output_ptr = (png_charpp)png_large_malloc(png_ptr,
+               output_ptr = (png_charpp)png_large_malloc(png_ptr,
-						max_output_ptr * sizeof (png_charp));
+                  max_output_ptr * sizeof (png_charp));
-			}
+         }
 
-			/* save off the data */
+         /* save off the data */
-			output_ptr[num_output_ptr] = png_large_malloc(png_ptr,
+         output_ptr[num_output_ptr] = png_large_malloc(png_ptr,
-				png_ptr->zbuf_size);
+            png_ptr->zbuf_size);
-			png_memcpy(output_ptr[num_output_ptr], png_ptr->zbuf,
+         png_memcpy(output_ptr[num_output_ptr], png_ptr->zbuf,
             (png_size_t)png_ptr->zbuf_size);
          num_output_ptr++;
 
@@ -560,7 +560,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
    } while (ret != Z_STREAM_END);
 
    /* text length is number of buffers plus last buffer */
-	text_len = png_ptr->zbuf_size * num_output_ptr;
+   text_len = png_ptr->zbuf_size * num_output_ptr;
    if (png_ptr->zstream->avail_out < png_ptr->zbuf_size)
       text_len += (png_uint_32)(png_ptr->zbuf_size -
          png_ptr->zstream->avail_out);
@@ -570,7 +570,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
       (png_uint_32)(key_len + text_len + 2));
    /* write key */
    png_write_chunk_data(png_ptr, (png_bytep )key, (png_uint_32)(key_len + 1));
-	buf[0] = (png_byte)compression;
+   buf[0] = (png_byte)compression;
    /* write compression */
    png_write_chunk_data(png_ptr, (png_bytep )buf, (png_uint_32)1);
 
@@ -578,7 +578,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
    for (i = 0; i < num_output_ptr; i++)
    {
       png_write_chunk_data(png_ptr, (png_bytep )output_ptr[i], png_ptr->zbuf_size);
-		png_large_free(png_ptr, output_ptr[i]);
+      png_large_free(png_ptr, output_ptr[i]);
    }
    if (max_output_ptr)
       png_large_free(png_ptr, output_ptr);
@@ -590,7 +590,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
    png_write_chunk_end(png_ptr);
 
    /* reset zlib for another zTXt or the image data */
-	deflateReset(png_ptr->zstream);
+   deflateReset(png_ptr->zstream);
 }
 #endif
 
@@ -605,7 +605,7 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
 
    png_save_uint_32(buf, x_pixels_per_unit);
    png_save_uint_32(buf + 4, y_pixels_per_unit);
-	buf[8] = (png_byte)unit_type;
+   buf[8] = (png_byte)unit_type;
 
    png_write_chunk(png_ptr, png_pHYs, buf, (png_uint_32)9);
 }
@@ -622,7 +622,7 @@ png_write_oFFs(png_structp png_ptr, png_uint_32 x_offset,
 
    png_save_uint_32(buf, x_offset);
    png_save_uint_32(buf + 4, y_offset);
-	buf[8] = (png_byte)unit_type;
+   buf[8] = (png_byte)unit_type;
 
    png_write_chunk(png_ptr, png_oFFs, buf, (png_uint_32)9);
 }
@@ -668,7 +668,7 @@ png_write_start_row(png_structp png_ptr)
    }
 
    /* if interlaced, we need to set up width and height of pass */
-	if (png_ptr->interlaced)
+   if (png_ptr->interlaced)
    {
       if (!(png_ptr->transformations & PNG_INTERLACE))
       {
@@ -686,7 +686,7 @@ png_write_start_row(png_structp png_ptr)
       }
    }
    else
-	{
+   {
       png_ptr->num_rows = png_ptr->height;
       png_ptr->usr_width = png_ptr->width;
    }
@@ -704,7 +704,7 @@ png_write_finish_row(png_structp png_ptr)
    png_ptr->row_number++;
    /* see if we are done */
    if (png_ptr->row_number < png_ptr->num_rows)
-		return;
+      return;
 
    /* if interlaced, go to next pass */
    if (png_ptr->interlaced)
@@ -722,7 +722,7 @@ png_write_finish_row(png_structp png_ptr)
             png_ptr->pass++;
             if (png_ptr->pass >= 7)
                break;
-				png_ptr->usr_width = (png_ptr->width +
+            png_ptr->usr_width = (png_ptr->width +
                png_pass_inc[png_ptr->pass] - 1 -
                png_pass_start[png_ptr->pass]) /
                png_pass_inc[png_ptr->pass];
@@ -740,7 +740,7 @@ png_write_finish_row(png_structp png_ptr)
       if (png_ptr->prev_row)
          png_memset(png_ptr->prev_row, 0, (png_size_t)png_ptr->rowbytes + 1);
       /* if we have more data to get, go get it */
-		if (png_ptr->pass < 7)
+      if (png_ptr->pass < 7)
          return;
    }
 
@@ -749,7 +749,7 @@ png_write_finish_row(png_structp png_ptr)
    do
    {
       /* tell the compressor we are done */
-		ret = deflate(png_ptr->zstream, Z_FINISH);
+      ret = deflate(png_ptr->zstream, Z_FINISH);
       /* check for an error */
       if (ret != Z_OK && ret != Z_STREAM_END)
       {
@@ -758,7 +758,7 @@ png_write_finish_row(png_structp png_ptr)
          else
             png_error(png_ptr, "zlib error");
       }
-		/* check to see if we need more room */
+      /* check to see if we need more room */
       if (!png_ptr->zstream->avail_out && ret == Z_OK)
       {
          png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
@@ -794,7 +794,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
    {
       /* each pixel depth is handled seperately */
       switch (row_info->pixel_depth)
-		{
+      {
          case 1:
          {
             png_bytep sp;
@@ -812,13 +812,13 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                i += png_pass_inc[pass])
             {
                sp = row + (png_size_t)(i >> 3);
-					value = (int)(*sp >> (7 - (int)(i & 7))) & 0x1;
+               value = (int)(*sp >> (7 - (int)(i & 7))) & 0x1;
                d |= (value << shift);
 
                if (shift == 0)
                {
                   shift = 7;
-						*dp++ = (png_byte)d;
+                  *dp++ = (png_byte)d;
                   d = 0;
                }
                else
@@ -826,11 +826,11 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
 
             }
             if (shift != 7)
-					*dp = (png_byte)d;
+               *dp = (png_byte)d;
             break;
          }
          case 2:
-			{
+         {
             png_bytep sp;
             png_bytep dp;
             int shift;
@@ -852,21 +852,21 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                if (shift == 0)
                {
                   shift = 6;
-						*dp++ = (png_byte)d;
+                  *dp++ = (png_byte)d;
                   d = 0;
                }
                else
                   shift -= 2;
             }
             if (shift != 6)
-						 *dp = (png_byte)d;
+                   *dp = (png_byte)d;
             break;
          }
          case 4:
          {
             png_bytep sp;
             png_bytep dp;
-				int shift;
+            int shift;
             int d;
             int value;
             png_uint_32 i;
@@ -884,15 +884,15 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
 
                if (shift == 0)
                {
-						shift = 4;
+                  shift = 4;
-						*dp++ = (png_byte)d;
+                  *dp++ = (png_byte)d;
                   d = 0;
                }
                else
                   shift -= 4;
             }
             if (shift != 4)
-					*dp = (png_byte)d;
+               *dp = (png_byte)d;
             break;
          }
          default:
@@ -902,7 +902,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             png_uint_32 i;
             int pixel_bytes;
 
-				/* start at the beginning */
+            /* start at the beginning */
             dp = row;
             /* find out how many bytes each pixel takes up */
             pixel_bytes = (row_info->pixel_depth >> 3);
@@ -920,7 +920,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                /* next pixel */
                dp += pixel_bytes;
             }
-				break;
+            break;
          }
       }
       /* set new row width */
@@ -944,7 +944,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
    int minf, bpp;
    png_uint_32 i, v;
    png_uint_32 s0, s1, s2, s3, s4, mins;
-	png_bytep rp, pp, cp, lp;
+   png_bytep rp, pp, cp, lp;
 
    /* find out how many bytes offset each pixel is */
    bpp = (row_info->pixel_depth + 7) / 8;
@@ -956,7 +956,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
       zero using anything >= 128 as negitive numbers. */
    s0 = s1 = s2 = s3 = s4 = 0;
 
-	for (i = 0, rp = row + 1, pp = prev_row + 1, lp = row + 1 - bpp,
+   for (i = 0, rp = row + 1, pp = prev_row + 1, lp = row + 1 - bpp,
          cp = prev_row + 1 - bpp;
       i < bpp; i++, rp++, pp++, lp++, cp++)
    {
@@ -992,7 +992,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
    {
       int a, b, c, pa, pb, pc, p;
 
-		/* check none filter */
+      /* check none filter */
       v = *rp;
       if (v < 128)
          s0 += v;
@@ -1010,7 +1010,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
       /* check up filter */
       v = (png_byte)(((int)*rp - (int)*pp) & 0xff);
 
-		if (v < 128)
+      if (v < 128)
          s2 += v;
       else
          s2 += 256 - v;
@@ -1028,7 +1028,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
       c = *cp;
       a = *lp;
       p = a + b - c;
-		pa = abs(p - a);
+      pa = abs(p - a);
       pb = abs(p - b);
       pc = abs(p - c);
 
@@ -1052,7 +1052,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
 
    if (s1 < mins)
    {
-		mins = s1;
+      mins = s1;
       minf = 1;
    }
 
@@ -1064,7 +1064,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
 
    if (s3 < mins)
    {
-		mins = s3;
+      mins = s3;
       minf = 3;
    }
 
@@ -1074,20 +1074,20 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
    }
 
    /* set filter byte */
-	row[0] = (png_byte)minf;
+   row[0] = (png_byte)minf;
 
    /* do filter */
    switch (minf)
    {
       /* sub filter */
       case 1:
-			for (i = bpp, rp = row + (png_size_t)row_info->rowbytes,
+         for (i = bpp, rp = row + (png_size_t)row_info->rowbytes,
             lp = row + (png_size_t)row_info->rowbytes - bpp;
             i < row_info->rowbytes; i++, rp--, lp--)
          {
             *rp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
          }
-			break;
+         break;
       /* up filter */
       case 2:
          for (i = 0, rp = row + (png_size_t)row_info->rowbytes,
@@ -1099,7 +1099,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
          break;
       /* avg filter */
       case 3:
-			for (i = row_info->rowbytes,
+         for (i = row_info->rowbytes,
             rp = row + (png_size_t)row_info->rowbytes,
             pp = prev_row + (png_size_t)row_info->rowbytes,
             lp = row + (png_size_t)row_info->rowbytes - bpp;
@@ -1117,7 +1117,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
       case 4:
          for (i = row_info->rowbytes,
             rp = row + (png_size_t)row_info->rowbytes,
-				pp = prev_row + (png_size_t)row_info->rowbytes,
+            pp = prev_row + (png_size_t)row_info->rowbytes,
             lp = row + (png_size_t)row_info->rowbytes - bpp,
             cp = prev_row + (png_size_t)row_info->rowbytes - bpp;
             i > 0; i--, rp--, lp--, pp--, cp--)
@@ -1135,7 +1135,7 @@ png_write_filter_row(png_row_infop row_info, png_bytep row,
                a = c = 0;
             }
             p = a + b - c;
-				pa = abs(p - a);
+            pa = abs(p - a);
             pb = abs(p - b);
             pc = abs(p - c);
 

readme.txt

@@ -1,8 +1,8 @@
-readme.txt - for libpng 0.87
+readme.txt - for libpng 0.88
 
 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
+a more secure progressive (push) reader.  The progressive reader
-tested as much as the pull reader, but seems to work ok.
+hasn't been tested as much as the pull reader, but seems to work ok.
 
 I've implemented the callback functions for the error/warning
 messages and the input/output.  See the libpng.txt