AuroraMiddleware/libpng
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Imported from libpng-0.88.tar

Browse Source
This commit is contained in:
Guy Schalnat 1996-01-26 01:38:47 -06:00 committed by Glenn Randers-Pehrson
parent 4ee97b0891
commit b2e01bd505
36 changed files with 3932 additions and 2578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

488
ansi2knr.c Normal file
View File

@ -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;
}

2
build.bat Normal file
View File

@ -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

50
descrip.mms Normal file
View File

@ -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

240
example.c
View File

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

905
libpng.txt
View File

File diff suppressed because it is too large Load Diff

15
makefile.sun → makefile
View File

@ -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
CFLAGS=-I../zlib -O2 -Wall
CC=cc
CFLAGS=-I../zlib -O
LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
RANLIB=ranlib
#RANLIB=echo
#RANLIB=ranlib
RANLIB=echo
# where make install puts libpng.a and png.h
prefix=/home/munet-d2/sun/local
prefix=/usr/local
OBJS = png.o pngrcb.o pngrutil.o pngtrans.o pngwutil.o \
pngread.o pngio.o pngwrite.o pngrtran.o pngwtran.o \
@ -31,12 +31,11 @@ test: pngtest
install: libpng.a
-@mkdir $(prefix)/include
-@mkdir $(prefix)/lib
cp png.h pngconf.h $(prefix)/include
rcp png.h pngconf.h vlsi:bin/include
cp png.h $(prefix)/include
cp pngconf.h $(prefix)/include
chmod 644 $(prefix)/include/png.h
chmod 644 $(prefix)/include/pngconf.h
cp libpng.a $(prefix)/lib
rcp libpng.a vlsi:bin/lib
chmod 644 $(prefix)/lib/libpng.a
clean:

42
makefile.ama Normal file
View File

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

31
makefile.atr Normal file
View File

@ -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

165
makefile.bor Normal file
View File

@ -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

2
makefile.elf
View File

@ -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

50
makefile.gcc Normal file
View File

@ -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

71
makefile.knr Normal file
View File

@ -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

60
makefile.mip Normal file
View File

@ -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

78
makefile.msc Normal file
View File

@ -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

60
makefile.std Normal file
View File

@ -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

69
makefile.tc Normal file
View File

@ -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

121
makevms.com Normal file
View File

@ -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

50
png.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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_uint_32 num_bytes;
png_voidp ptr;
png_uint_32 num_bytes;
ptr = png_large_malloc((png_structp)png_ptr,
(png_uint_32)items * (png_uint_32)size);
num_bytes = (png_uint_32)items * (png_uint_32)size;
if (num_bytes > (png_uint_32)0x7fff)
{
png_memset(ptr, 0, (png_size_t)0x8000L);
png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
(png_size_t)(num_bytes - (png_uint_32)0x8000L));
}
else
{
png_memset(ptr, 0, (png_size_t)num_bytes);
}
ptr = png_large_malloc((png_structp)png_ptr,
(png_uint_32)items * (png_uint_32)size);
num_bytes = (png_uint_32)items * (png_uint_32)size;
if (num_bytes > (png_uint_32)0x7fff)
{
png_memset(ptr, 0, (png_size_t)0x8000L);
png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
(png_size_t)(num_bytes - (png_uint_32)0x8000L));
}
else
{
png_memset(ptr, 0, (png_size_t)num_bytes);
}
return (voidpf)(ptr);
}
@ -130,7 +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
variables are large enough */
PNG spec, with appropriate modifications made to ensure the
variables are large enough */
/* table of crc's of all 8-bit messages. If you wish to png_malloc this
table, turn this into a pointer, and png_malloc it in make_crc_table().
@ -193,7 +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));
}

30
png.h
View File

@ -1,8 +1,8 @@
/* png.h - header file for png reference library
libpng 1.0 beta 2 - version 0.87
Jan 15, 1996
libpng 1.0 beta 2 - version 0.88
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"
/* careful here. I wanted to use 087, but that would be octal. Version
#define PNG_LIBPNG_VER_STRING "0.88"
/* 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

56
pngchang.txt
View File

@ -1,31 +1,31 @@
pngchange.txt - changes for libpng
version 0.2
added reader into png.h
fixed small problems in stub file
added reader into png.h
fixed small problems in stub file
version 0.3
added pull reader
split up pngwrite.c to several files
added pnglib.txt
added example.c
cleaned up writer, adding a few new tranformations
fixed some bugs in writer
interfaced with zlib 0.5
added K&R support
added check for 64 KB blocks for 16 bit machines
added pull reader
split up pngwrite.c to several files
added pnglib.txt
added example.c
cleaned up writer, adding a few new tranformations
fixed some bugs in writer
interfaced with zlib 0.5
added K&R support
added check for 64 KB blocks for 16 bit machines
version 0.4
cleaned up code and commented code
simplified time handling into png_time
created png_color_16 and png_color_8 to handle color needs
cleaned up color type defines
fixed various bugs
made various names more consistant
interfaced with zlib 0.71
cleaned up zTXt reader and writer (using zlib's Reset functions)
split transformations into pngrtran.c and pngwtran.c
cleaned up code and commented code
simplified time handling into png_time
created png_color_16 and png_color_8 to handle color needs
cleaned up color type defines
fixed various bugs
made various names more consistant
interfaced with zlib 0.71
cleaned up zTXt reader and writer (using zlib's Reset functions)
split transformations into pngrtran.c and pngwtran.c
version 0.5
interfaced with zlib 0.8
fixed many reading and writing bugs
interfaced with zlib 0.8
fixed many reading and writing bugs
saved using 3 spaces instead of tabs
version 0.6
added png_large_malloc() and png_large_free()
@ -54,7 +54,8 @@ version 0.8
changed external functions passing floats to doubles (k&r problems?)
put all the configurable stuff in pngconf.h
enabled png_set_shift to work with paletted images on read
added png_read_update_info() - updates info structure with transformations
added png_read_update_info() - updates info structure with
transformations
version 0.81
incorporated Tim Wegner's medium model code (thanks, Tim)
version 0.85
@ -66,7 +67,10 @@ version 0.86
fixed bugs
improved documentation
version 0.87
fixed medium model bugs
fixed other bugs introduced in 0.85 and 0.86
fixed medium model bugs
fixed other bugs introduced in 0.85 and 0.86
added some minor documentation
version 0.88
fixed progressive bugs
replaced tabs with spaces
cleaned up documentation

34
pngconf.h
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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:
stdin, stdout, and stderr. The only one currently used is stderr
in png_error() and png_warning(). #defining PNG_NO_STDIO will
prevent these from being compiled and used. */
and thus don't have or would rather us not use the stdio types:
stdin, stdout, and stderr. The only one currently used is stderr
in png_error() and png_warning(). #defining PNG_NO_STDIO will
prevent these from being compiled and used. */
/* #define PNG_NO_STDIO */
@ -138,11 +138,11 @@
#endif /* PNG_INTERNAL */
/* the following uses const char * instead of char * for error
and warning message functions, so some compilers won't complain.
If you want to use const, define PNG_USE_CONST here. It is not
normally defined to make configuration easier, as it is not a
and warning message functions, so some compilers won't complain.
If you want to use const, define PNG_USE_CONST here. It is not
normally defined to make configuration easier, as it is not a
critical part of the code.
*/
*/
#ifdef PNG_USE_CONST
# define PNG_CONST const
@ -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

92
pngerror.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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
at each function. */
and use png_set_message_fn() to use those functions. See the instructions
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,
you should supply a replacement error function and use png_set_message_fn()
should not be changed. If there is a need to handle errors differently,
you should supply a replacement error function and use png_set_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)
(*(png_ptr->error_fn))(png_ptr, message);
if (png_ptr->error_fn)
(*(png_ptr->error_fn))(png_ptr, message);
/* if the following returns or doesn't exist, use the default function,
which will not return */
png_default_error(png_ptr, message);
/* if the following returns or doesn't exist, use the default function,
which will not return */
png_default_error(png_ptr, message);
}
/* This function is called whenever there is a non-fatal error. This function
should not be changed. If there is a need to handle warnings differently,
you should supply a replacement warning function and use
png_set_message_fn() to replace the warning function at run-time. */
should not be changed. If there is a need to handle warnings differently,
you should supply a replacement warning function and use
png_set_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)
(*(png_ptr->warning_fn))(png_ptr, message);
else
png_default_warning(png_ptr, message);
if (png_ptr->warning_fn)
(*(png_ptr->warning_fn))(png_ptr, message);
else
png_default_warning(png_ptr, message);
}
/* This is the default error handling function. Note that replacements for
this function MUST NOT RETURN, or the program will likely crash. This
function is used by default, or if the program supplies NULL for the
error function pointer in png_set_message_fn(). */
this function MUST NOT RETURN, or the program will likely crash. This
function is used by default, or if the program supplies NULL for the
error function pointer in png_set_message_fn(). */
void
png_default_error(png_structp png_ptr, png_const_charp message)
{
#ifndef PNG_NO_STDIO
fprintf(stderr, "libpng error: %s\n", message);
fprintf(stderr, "libpng error: %s\n", message);
#endif
#ifdef USE_FAR_KEYWORD
{
jmp_buf jmpbuf;
png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
longjmp(jmpbuf, 1);
}
{
jmp_buf jmpbuf;
png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
longjmp(jmpbuf, 1);
}
#else
longjmp(png_ptr->jmpbuf, 1);
longjmp(png_ptr->jmpbuf, 1);
#endif
}
/* This function is called when there is a warning, but the library thinks
it can continue anyway. Replacement functions don't have to do anything
here if you don't want to. In the default configuration, png_ptr is
it can continue anyway. Replacement functions don't have to do anything
here if you don't want to. In the default configuration, png_ptr is
not used, but it is passed in case it may be useful. */
void
png_default_warning(png_structp png_ptr, png_const_charp message)
{
if (!png_ptr)
return;
if (!png_ptr)
return;
#ifndef PNG_NO_STDIO
fprintf(stderr, "libpng warning: %s\n", message);
fprintf(stderr, "libpng warning: %s\n", message);
#endif
}
/* This function is called when the application wants to use another method
of handling errors and warnings. Note that the error function MUST NOT
return to the calling routine or serious problems will occur. The error
return method used in the default routine calls
longjmp(png_ptr->jmpbuf, 1) */
of handling errors and warnings. Note that the error function MUST NOT
return to the calling routine or serious problems will occur. The error
return method used in the default routine calls
longjmp(png_ptr->jmpbuf, 1) */
void
png_set_message_fn(png_structp png_ptr, png_voidp msg_ptr, png_msg_ptr error_fn,
png_msg_ptr warning_fn)
png_msg_ptr warning_fn)
{
png_ptr->msg_ptr = msg_ptr;
png_ptr->msg_ptr = msg_ptr;
png_ptr->error_fn = error_fn;
png_ptr->warning_fn = warning_fn;
png_ptr->error_fn = error_fn;
png_ptr->warning_fn = warning_fn;
}
/* This function returns a pointer to the msg_ptr associated with the user
functions. The application should free any memory associated with this
pointer before png_write_destroy and png_read_destroy are called. */
functions. The application should free any memory associated with this
pointer before png_write_destroy and png_read_destroy are called. */
png_voidp
png_get_msg_ptr(png_structp png_ptr)
{
return png_ptr->msg_ptr;
return png_ptr->msg_ptr;
}

266
pngio.c
View File

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

372
pngmem.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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
to meet their needs. See the instructions at each function. */
need special memory handling are expected to modify the code in this file
to meet their needs. See the instructions at each function. */
#define PNG_INTERNAL
#include "png.h"
@ -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
it not to. See zconf.h and png.h for more information. zlib does
need to allocate exactly 64K, so whatever you call here must
have the ability to do that. */
64K. However, zlib may allocate more then 64K if you don't tell
it not to. See zconf.h and png.h for more information. zlib does
need to allocate exactly 64K, so whatever you call here must
have the ability to do that. */
/* Borland seems to have a problem in DOS mode for exactly 64K.
It gives you a segment with an offset of 8 (perhaps to store it's
memory stuff). zlib doesn't like this at all, so we have to
detect and deal with it. This code should not be needed in
It gives you a segment with an offset of 8 (perhaps to store it's
memory stuff). zlib doesn't like this at all, so we have to
detect and deal with it. This code should not be needed in
Windows or OS/2 modes, and only in 16 bit mode.
*/
png_voidp
png_large_malloc(png_structp png_ptr, png_uint_32 size)
{
png_voidp ret;
if (!png_ptr || !size)
return ((voidp)0);
png_voidp ret;
if (!png_ptr || !size)
return ((voidp)0);
#ifdef PNG_MAX_MALLOC_64K
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
#endif
if (size == (png_uint_32)(65536L))
{
if (!png_ptr->offset_table)
{
/* try to see if we need to do any of this fancy stuff */
ret = farmalloc(size);
if (!ret || ((long)ret & 0xffff))
{
int num_blocks;
png_uint_32 total_size;
png_bytep table;
int i;
if (size == (png_uint_32)(65536L))
{
if (!png_ptr->offset_table)
{
/* try to see if we need to do any of this fancy stuff */
ret = farmalloc(size);
if (!ret || ((long)ret & 0xffff))
{
int num_blocks;
png_uint_32 total_size;
png_bytep table;
int i;
png_byte huge * hptr;
if (ret)
farfree(ret);
ret = 0;
if (ret)
farfree(ret);
ret = 0;
num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
if (num_blocks < 1)
num_blocks = 1;
if (png_ptr->zlib_mem_level >= 7)
num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
else
num_blocks++;
num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
if (num_blocks < 1)
num_blocks = 1;
if (png_ptr->zlib_mem_level >= 7)
num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
else
num_blocks++;
total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks;
total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks;
table = farmalloc(total_size);
table = farmalloc(total_size);
if (!table)
{
png_error(png_ptr, "Out of Memory");
}
if (!table)
{
png_error(png_ptr, "Out of Memory");
}
if ((long)table & 0xffff)
{
farfree(table);
total_size += (png_uint_32)65536L;
}
if ((long)table & 0xffff)
{
farfree(table);
total_size += (png_uint_32)65536L;
}
table = farmalloc(total_size);
table = farmalloc(total_size);
if (!table)
{
png_error(png_ptr, "Out of Memory");
}
if (!table)
{
png_error(png_ptr, "Out of Memory");
}
png_ptr->offset_table = table;
png_ptr->offset_table_ptr = farmalloc(
num_blocks * sizeof (png_bytep));
hptr = (png_byte huge *)table;
if ((long)hptr & 0xffff)
{
hptr = (png_byte huge *)((long)(hptr) & 0xffff0000L);
hptr += 65536L;
}
for (i = 0; i < num_blocks; i++)
{
png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
hptr += 65536L;
}
png_ptr->offset_table = table;
png_ptr->offset_table_ptr = farmalloc(
num_blocks * sizeof (png_bytep));
hptr = (png_byte huge *)table;
if ((long)hptr & 0xffff)
{
hptr = (png_byte huge *)((long)(hptr) & 0xffff0000L);
hptr += 65536L;
}
for (i = 0; i < num_blocks; i++)
{
png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
hptr += 65536L;
}
png_ptr->offset_table_number = num_blocks;
png_ptr->offset_table_count = 0;
png_ptr->offset_table_count_free = 0;
}
png_ptr->offset_table_number = num_blocks;
png_ptr->offset_table_count = 0;
png_ptr->offset_table_count_free = 0;
}
if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
png_error(png_ptr, "Out of Memory");
if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
png_error(png_ptr, "Out of Memory");
ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
}
}
else
ret = farmalloc(size);
if (ret == NULL)
{
png_error(png_ptr, "Out of Memory");
}
return ret;
}
/* free a pointer allocated by png_large_malloc(). In the default
configuration, png_ptr is not used, but is passed in case it
is needed. If ptr is NULL, return without taking any action. */
void
png_large_free(png_structp png_ptr, png_voidp ptr)
{
if (!png_ptr)
return;
if (ptr != NULL)
{
if (png_ptr->offset_table)
{
int i;
for (i = 0; i < png_ptr->offset_table_count; i++)
{
if (ptr == png_ptr->offset_table_ptr[i])
{
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
}
}
else
ret = farmalloc(size);
if (ret == NULL)
{
png_error(png_ptr, "Out of Memory");
}
return ret;
return ret;
}
/* free a pointer allocated by png_large_malloc(). In the default
@ -211,29 +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
must come from the local heap (for zlib). Currently, zlib is
the only one that uses this, so you should only get one call
to this, and that a small block. */
should not get anywhere near 64K. On segmented machines, this
must come from the local heap (for zlib). Currently, zlib is
the only one that uses this, so you should only get one call
to this, and that a small block. */
void *
png_malloc(png_structp png_ptr, png_uint_32 size)
{
@ -252,39 +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
the current version of the library. */
even marginally reasonable file. This is not used in
the current version of the library. */
void *
png_realloc(png_structp png_ptr, void * ptr, png_uint_32 size,
png_uint_32 old_size)
png_uint_32 old_size)
{
void *ret;
void *ret;
if (!png_ptr || !old_size || !ptr || !size)
return ((void *)0);
if (!png_ptr || !old_size || !ptr || !size)
return ((void *)0);
#ifdef PNG_MAX_MALLOC_64K
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
#endif
ret = realloc(ptr, (png_size_t)size);
ret = realloc(ptr, (png_size_t)size);
if (!ret)
{
png_error(png_ptr, "Out of Memory 7");
}
if (!ret)
{
png_error(png_ptr, "Out of Memory 7");
}
return ret;
return ret;
}
/* free a pointer allocated by png_malloc(). In the default
@ -293,11 +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)
return;
if (!png_ptr)
return;
if (ptr != (void *)0)
free(ptr);
if (ptr != (void *)0)
free(ptr);
}

1821
pngpread.c
View File

File diff suppressed because it is too large Load Diff

56
pngrcb.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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->color_type =(png_byte) color_type;
info->compression_type = (png_byte)compression_type;
info->filter_type = (png_byte)filter_type;
info->interlace_type = (png_byte)interlace_type;
info->bit_depth = (png_byte)bit_depth;
info->color_type =(png_byte) color_type;
info->compression_type = (png_byte)compression_type;
info->filter_type = (png_byte)filter_type;
info->interlace_type = (png_byte)interlace_type;
if (info->color_type == PNG_COLOR_TYPE_PALETTE)
info->channels = 1;
else if (info->color_type & PNG_COLOR_MASK_COLOR)
@ -33,7 +33,7 @@ png_read_IHDR(png_structp png_ptr, png_infop info,
info->channels = 1;
if (info->color_type & PNG_COLOR_MASK_ALPHA)
info->channels++;
info->pixel_depth = (png_byte)(info->channels * info->bit_depth);
info->pixel_depth = (png_byte)(info->channels * info->bit_depth);
info->rowbytes = ((info->width * info->pixel_depth + 7) >> 3);
}
@ -45,7 +45,7 @@ png_read_PLTE(png_structp png_ptr, png_infop info,
return;
info->palette = palette;
info->num_palette = (png_uint_16)num;
info->num_palette = (png_uint_16)num;
info->valid |= PNG_INFO_PLTE;
}
@ -69,7 +69,7 @@ png_read_sBIT(png_structp png_ptr, png_infop info,
if (!png_ptr || !info)
return;
png_memcpy(&(info->sig_bit), sig_bit, sizeof (png_color_8));
png_memcpy(&(info->sig_bit), sig_bit, sizeof (png_color_8));
info->valid |= PNG_INFO_sBIT;
}
#endif
@ -77,8 +77,8 @@ png_read_sBIT(png_structp png_ptr, png_infop info,
#if defined(PNG_READ_cHRM_SUPPORTED)
void
png_read_cHRM(png_structp png_ptr, png_infop info,
double white_x, double white_y, double red_x, double red_y,
double green_x, double green_y, double blue_x, double blue_y)
double white_x, double white_y, double red_x, double red_y,
double green_x, double green_y, double blue_x, double blue_y)
{
if (!png_ptr || !info)
return;
@ -112,7 +112,7 @@ png_read_tRNS(png_structp png_ptr, png_infop info,
png_memcpy(&(info->trans_values), trans_values,
sizeof(png_color_16));
}
info->num_trans = (png_uint_16)num_trans;
info->num_trans = (png_uint_16)num_trans;
info->valid |= PNG_INFO_tRNS;
}
#endif
@ -152,7 +152,7 @@ png_read_pHYs(png_structp png_ptr, png_infop info,
info->x_pixels_per_unit = res_x;
info->y_pixels_per_unit = res_y;
info->phys_unit_type = (png_byte)unit_type;
info->phys_unit_type = (png_byte)unit_type;
info->valid |= PNG_INFO_pHYs;
}
#endif
@ -175,7 +175,7 @@ png_read_oFFs(png_structp png_ptr, png_infop info,
#if defined(PNG_READ_tIME_SUPPORTED)
void
png_read_tIME(png_structp png_ptr, png_infop info,
png_timep mod_time)
png_timep mod_time)
{
if (!png_ptr || !info)
return;
@ -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;
{
png_textp old_text;
info->max_text = info->num_text + 16;
{
png_textp old_text;
old_text = info->text;
info->text = (png_textp)png_large_malloc(png_ptr,
info->max_text * sizeof (png_text));
png_memcpy(info->text, old_text,
(png_size_t)(old_max * sizeof (png_text)));
png_large_free(png_ptr, old_text);
}
old_text = info->text;
info->text = (png_textp)png_large_malloc(png_ptr,
info->max_text * sizeof (png_text));
png_memcpy(info->text, old_text,
(png_size_t)(old_max * sizeof (png_text)));
png_large_free(png_ptr, old_text);
}
}
else
{
@ -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

4
pngread.c
View File

@ -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

662
pngrtran.c
View File

File diff suppressed because it is too large Load Diff

160
pngrutil.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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) +
(png_uint_16)(*(buf + 1)));
i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
(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->interlaced = (png_byte)interlace_type;
png_ptr->color_type = (png_byte)color_type;
png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr->interlaced = (png_byte)interlace_type;
png_ptr->color_type = (png_byte)color_type;
/* find number of channels */
switch (png_ptr->color_type)
@ -143,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->channels);
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
png_ptr->channels);
png_ptr->rowbytes = ((png_ptr->width *
(png_uint_32)png_ptr->pixel_depth + 7) >> 3);
/* call the IHDR callback (which should just set up info) */
@ -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);
return;
png_crc_skip(png_ptr, length);
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);
return;
png_crc_skip(png_ptr, length);
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_ptr->num_trans = (png_uint_16)length;
png_crc_read(png_ptr, png_ptr->trans, length);
png_ptr->num_trans = (png_uint_16)length;
}
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
{
@ -322,7 +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);
return;
}
png_crc_skip(png_ptr, length);
return;
}
png_crc_read(png_ptr, buf, 2);
png_ptr->num_trans = 1;
png_ptr->trans_values.gray = png_get_uint_16(buf);
}
else
png_crc_read(png_ptr, buf, 2);
png_ptr->num_trans = 1;
png_ptr->trans_values.gray = png_get_uint_16(buf);
}
else
png_warning(png_ptr, "Invalid tRNS chunk");
png_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_crc_skip(png_ptr, length);
png_warning(png_ptr, "Incorrect bKGD chunk 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)
{
png_warning(png_ptr, "Incorrect hIST chunk length");
png_crc_skip(png_ptr, length);
return;
}
if (length != 2 * png_ptr->num_palette)
{
png_warning(png_ptr, "Incorrect hIST chunk length");
png_crc_skip(png_ptr, length);
return;
}
num = (int)length / 2;
png_ptr->hist = (png_uint_16p)png_large_malloc(png_ptr,
num * sizeof (png_uint_16));
png_ptr->hist = (png_uint_16p)png_large_malloc(png_ptr,
num * sizeof (png_uint_16));
png_ptr->do_free |= PNG_FREE_HIST;
for (i = 0; i < num; i++)
for (i = 0; i < num; i++)
{
png_byte buf[2];
@ -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_crc_skip(png_ptr, length);
png_warning(png_ptr, "Incorrect pHYs chunk length");
png_crc_skip(png_ptr, length);
return;
}
}
png_crc_read(png_ptr, buf, 9);
@ -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_crc_skip(png_ptr, length);
png_warning(png_ptr, "Incorrect oFFs chunk length");
png_crc_skip(png_ptr, length);
return;
}
png_crc_read(png_ptr, buf, 9);
png_crc_read(png_ptr, buf, 9);
offset_x = png_get_uint_32(buf);
offset_y = png_get_uint_32(buf + 4);
@ -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_crc_skip(png_ptr, length);
png_warning(png_ptr, "Incorrect tIME chunk 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);
png_crc_read(png_ptr, (png_bytep )key, length);
key = png_large_malloc(png_ptr, length + 1);
png_crc_read(png_ptr, (png_bytep )key, length);
key[(png_size_t)length] = '\0';
for (text = key; *text; text++)
@ -538,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)
png_warning(png_ptr, png_ptr->zstream->msg);
if (png_ptr->zstream->msg)
png_warning(png_ptr, png_ptr->zstream->msg);
else
png_warning(png_ptr, "zTXt decompression error");
inflateReset(png_ptr->zstream);
png_warning(png_ptr, "zTXt decompression error");
inflateReset(png_ptr->zstream);
png_ptr->zstream->avail_in = 0;
png_large_free(png_ptr, key);
png_large_free(png_ptr, text);
@ -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);

20
pngtest.c
View File

@ -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_write_rows(&write_ptr, (png_bytepp)&row_buf, 1);
png_read_rows(&read_ptr, (png_bytepp)&row_buf, (png_bytepp)0, 1);
png_write_rows(&write_ptr, (png_bytepp)&row_buf, 1);
}
}

8
pngtodo.txt
View File

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

8
pngtrans.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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;

184
pngwrite.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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->month = (png_byte)(ttime->tm_mon + 1);
ptime->day = (png_byte)ttime->tm_mday;
ptime->hour = (png_byte)ttime->tm_hour;
ptime->minute = (png_byte)ttime->tm_min;
ptime->second = (png_byte)ttime->tm_sec;
ptime->year = (png_uint_16)(1900 + ttime->tm_year);
ptime->month = (png_byte)(ttime->tm_mon + 1);
ptime->day = (png_byte)ttime->tm_mday;
ptime->hour = (png_byte)ttime->tm_hour;
ptime->minute = (png_byte)ttime->tm_min;
ptime->second = (png_byte)ttime->tm_sec;
}
void
@ -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 warning_fn;
png_voidp msg_ptr;
png_msg_ptr error_fn;
png_msg_ptr warning_fn;
png_voidp msg_ptr;
/* save jump buffer and error functions */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
error_fn = png_ptr->error_fn;
warning_fn = png_ptr->warning_fn;
msg_ptr = png_ptr->msg_ptr;
/* save jump buffer and error functions */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
error_fn = png_ptr->error_fn;
warning_fn = png_ptr->warning_fn;
msg_ptr = png_ptr->msg_ptr;
/* reset all variables to 0 */
png_memset(png_ptr, 0, sizeof (png_struct));
/* restore jump buffer and error functions */
/* reset all variables to 0 */
png_memset(png_ptr, 0, sizeof (png_struct));
/* restore jump buffer and error functions */
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
png_ptr->error_fn = error_fn;
png_ptr->warning_fn = warning_fn;
png_ptr->msg_ptr = msg_ptr;
png_ptr->error_fn = error_fn;
png_ptr->warning_fn = warning_fn;
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.channels);
png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
png_ptr->row_info.channels);
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
@ -336,7 +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
png_error(png_ptr, "zlib error");
else
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 */
png_write_finish_row(png_ptr);
/* finish row - updates counters and flushes zlib if last row */
png_write_finish_row(png_ptr);
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
png_ptr->flush_rows++;
png_ptr->flush_rows++;
if (png_ptr->flush_dist > 0 &&
png_ptr->flush_rows >= png_ptr->flush_dist)
{
png_write_flush(png_ptr);
}
if (png_ptr->flush_dist > 0 &&
png_ptr->flush_rows >= png_ptr->flush_dist)
{
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)
return;
if (png_ptr->mode != PNG_HAVE_IDAT)
return;
do
{
int ret;
do
{
int ret;
/* compress the data */
ret = deflate(png_ptr->zstream, Z_SYNC_FLUSH);
wrote_IDAT = 0;
/* compress the data */
ret = deflate(png_ptr->zstream, Z_SYNC_FLUSH);
wrote_IDAT = 0;
/* check for compression errors */
if (ret != Z_OK)
{
if (png_ptr->zstream->msg)
png_error(png_ptr, png_ptr->zstream->msg);
else
png_error(png_ptr, "zlib error");
}
/* check for compression errors */
if (ret != Z_OK)
{
if (png_ptr->zstream->msg)
png_error(png_ptr, png_ptr->zstream->msg);
else
png_error(png_ptr, "zlib error");
}
if (!png_ptr->zstream->avail_out)
{
/* write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size);
png_ptr->zstream->next_out = png_ptr->zbuf;
png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
wrote_IDAT = 1;
}
} while(wrote_IDAT == 1);
if (!png_ptr->zstream->avail_out)
{
/* write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size);
png_ptr->zstream->next_out = png_ptr->zbuf;
png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
wrote_IDAT = 1;
}
} while(wrote_IDAT == 1);
/* If there is any data left to be output, write it into a new IDAT */
if (png_ptr->zbuf_size != png_ptr->zstream->avail_out)
{
/* write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream->avail_out);
png_ptr->zstream->next_out = png_ptr->zbuf;
png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
}
png_ptr->flush_rows = 0;
png_flush(png_ptr);
/* If there is any data left to be output, write it into a new IDAT */
if (png_ptr->zbuf_size != png_ptr->zstream->avail_out)
{
/* write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream->avail_out);
png_ptr->zstream->next_out = png_ptr->zbuf;
png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
}
png_ptr->flush_rows = 0;
png_flush(png_ptr);
}
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
@ -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

40
pngwtran.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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;
png_int_32 i;
int mask;
png_int_32 i;
int v;
sp = row;
@ -78,13 +78,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
else
{
mask = 0x80;
*dp = (png_byte)v;
dp++;
*dp = (png_byte)v;
dp++;
v = 0;
}
}
if (mask != 0x80)
*dp = (png_byte)v;
*dp = (png_byte)v;
break;
}
case 2:
@ -94,7 +94,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
int shift;
png_int_32 i;
int v;
png_byte value;
png_byte value;
sp = row;
dp = row;
@ -102,12 +102,12 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
v = 0;
for (i = 0; i < row_info->width; i++)
{
value = (png_byte)(*sp & 0x3);
value = (png_byte)(*sp & 0x3);
v |= (value << shift);
if (shift == 0)
{
shift = 6;
*dp = (png_byte)v;
*dp = (png_byte)v;
dp++;
v = 0;
}
@ -116,7 +116,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
sp++;
}
if (shift != 6)
*dp = (png_byte)v;
*dp = (png_byte)v;
break;
}
case 4:
@ -134,13 +134,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
v = 0;
for (i = 0; i < row_info->width; i++)
{
value = (png_byte)(*sp & 0xf);
value = (png_byte)(*sp & 0xf);
v |= (value << shift);
if (shift == 0)
{
shift = 4;
*dp = (png_byte)v;
*dp = (png_byte)v;
dp++;
v = 0;
}
@ -150,12 +150,12 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_byte bit_depth)
sp++;
}
if (shift != 4)
*dp = (png_byte)v;
*dp = (png_byte)v;
break;
}
}
row_info->bit_depth = bit_depth;
row_info->pixel_depth = (png_uint_16)(bit_depth * row_info->channels);
row_info->pixel_depth = (png_uint_16)(bit_depth * row_info->channels);
row_info->rowbytes =
((row_info->width * row_info->pixel_depth + 7) >> 3);
}
@ -276,8 +276,8 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
{
png_uint_16 value, v;
v = (png_uint_16)(((png_uint_16)(*bp) << 8) +
(png_uint_16)(*(bp + 1)));
v = (png_uint_16)(((png_uint_16)(*bp) << 8) +
(png_uint_16)(*(bp + 1)));
value = 0;
for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
{
@ -286,7 +286,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
else
value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
}
*bp = (png_byte)(value >> 8);
*bp = (png_byte)(value >> 8);
*(bp + 1) = (png_byte)(value & 0xff);
}
}
@ -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;

192
pngwutil.c
View File

@ -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.
January 15, 1996
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
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[9] = (png_byte)color_type;
buf[10] = (png_byte)compression_type;
buf[11] = (png_byte)filter_type;
buf[12] = (png_byte)interlace_type;
/* save off the relevent information */
png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr->color_type = (png_byte)color_type;
png_ptr->interlaced = (png_byte)interlace_type;
buf[8] = (png_byte)bit_depth;
buf[9] = (png_byte)color_type;
buf[10] = (png_byte)compression_type;
buf[11] = (png_byte)filter_type;
buf[12] = (png_byte)interlace_type;
/* save off the relevent information */
png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr->color_type = (png_byte)color_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 blue_x, double blue_y)
double red_x, double red_y, double green_x, double green_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)
{
png_charpp old_ptr;
if (output_ptr)
{
png_charpp old_ptr;
old_ptr = output_ptr;
output_ptr = (png_charpp)png_large_malloc(png_ptr,
max_output_ptr * sizeof (png_charpp));
png_memcpy(output_ptr, old_ptr,
(png_size_t)(old_max * sizeof (png_charp)));
png_large_free(png_ptr, old_ptr);
}
else
output_ptr = (png_charpp)png_large_malloc(png_ptr,
max_output_ptr * sizeof (png_charp));
old_ptr = output_ptr;
output_ptr = (png_charpp)png_large_malloc(png_ptr,
max_output_ptr * sizeof (png_charpp));
png_memcpy(output_ptr, old_ptr,
(png_size_t)(old_max * sizeof (png_charp)));
png_large_free(png_ptr, old_ptr);
}
else
output_ptr = (png_charpp)png_large_malloc(png_ptr,
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 */
if (num_output_ptr >= max_output_ptr)
/* check to make sure our 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)
{
png_charpp old_ptr;
{
png_charpp old_ptr;
old_ptr = output_ptr;
output_ptr = (png_charpp)png_large_malloc(png_ptr,
max_output_ptr * sizeof (png_charpp));
png_memcpy(output_ptr, old_ptr,
(png_size_t)(old_max * sizeof (png_charp)));
png_large_free(png_ptr, old_ptr);
}
else
output_ptr = (png_charpp)png_large_malloc(png_ptr,
max_output_ptr * sizeof (png_charp));
}
old_ptr = output_ptr;
output_ptr = (png_charpp)png_large_malloc(png_ptr,
max_output_ptr * sizeof (png_charpp));
png_memcpy(output_ptr, old_ptr,
(png_size_t)(old_max * sizeof (png_charp)));
png_large_free(png_ptr, old_ptr);
}
else
output_ptr = (png_charpp)png_large_malloc(png_ptr,
max_output_ptr * sizeof (png_charp));
}
/* save off the data */
output_ptr[num_output_ptr] = png_large_malloc(png_ptr,
png_ptr->zbuf_size);
png_memcpy(output_ptr[num_output_ptr], png_ptr->zbuf,
/* save off the data */
output_ptr[num_output_ptr] = png_large_malloc(png_ptr,
png_ptr->zbuf_size);
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;
*dp++ = (png_byte)d;
shift = 4;
*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);

6
readme.txt
View File

@ -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
tested as much as the pull reader, but seems to work ok.
a more secure progressive (push) reader. The progressive reader
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