minecraft-pi-reborn/libpng
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Imported from libpng-0.97.tar

Browse Source
This commit is contained in:
Glenn Randers-Pehrson 1998-01-01 07:13:13 -06:00
parent 47a0c422ca
commit b6ce43d6ff
24 changed files with 1297 additions and 763 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
CHANGES
View File

@ -167,3 +167,21 @@ version 0.96 [May, 1997]
added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul) added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul)
added typecasts to quiet compiler errors added typecasts to quiet compiler errors
added more debugging info added more debugging info
version 1.00 [not distributed, but Andreas handed off to G&G]
skipped version 1.00 to avoid potential problems with shared libraries
created with version 0.89
removed PNG_USE_OWN_CRC capability
relocated png_set_crc_action from pngrutil.c to pngrtran.c
fixed typecasts of "new_key" etc.
added RFC 1152 date support
version 1.00.97 [Dec 1997]
fixed bug in gamma handling of 4-bit grayscale
added more typecasts. 65536L becomes (png_uint_32)65536L, etc.
minor corrections in libpng.txt
added simple sRGB support
make it simpler to do conditional compiling
fixed memory leak in pngwrite.c (free info_ptr->text)
added more conditions for png_do_background, to avoid changing
black pixels to background when a background is supplied and
no pixels are transparent
include stdio.h in pngconf.h even when PNG_NO_STDIO is defined.

23
README
View File

@ -1,9 +1,16 @@
README for libpng 0.96 README for libpng 1.10
This is the sixth (and hopefully last) beta release of libpng 1.0. This first official release of libpng. Don't let the fact that
The changes from libpng-0.90 include bug fixes, a C++ wrapper for it's the first release fool you. The libpng library has been in
png.h, some additions to the API, as well as internal changes to extensive use and testing for about two years. However, it's
the library. See "CHANGES" for a detailed list of differences. finally gotten to the stage where there haven't been significant
changes to the API in some time, and people have a bad feeling about
libraries with versions < 1.0.
Note that the version number is 1.10 to avoid potential problems
with shared libraries created for Linux ELF under version 0.89,
which mistakenly used 1.0.89 as the library version number in
false anticipation of an imminent 1.0 release.
**** ****
Note that some of the changes to the png_info structure render this Note that some of the changes to the png_info structure render this
@ -19,6 +26,12 @@ access to info_ptr. These functions are the png_set_<chunk> and
png_get_<chunk> functions. These functions should be used when png_get_<chunk> functions. These functions should be used when
accessing/storing the info_struct data, rather than manipulating it accessing/storing the info_struct data, rather than manipulating it
directly, to avoid such problems in the future. directly, to avoid such problems in the future.
It is important to note that the APIs do not make current programs
which access the info struct directly incompatible with the new
library. However, it is strongly suggested that new programs use
the new APIs (as shown in example.c), and older programs be converted
to the new format, to facilitate upgrades in the future.
**** ****
Additions since 0.90 include the ability to compile libpng as a Additions since 0.90 include the ability to compile libpng as a

120
example.c
View File

@ -1,36 +1,36 @@
/* example.c - an example of using libpng */ /* example.c - an example of using libpng */
/* This is an example of how to use libpng to read and write PNG files. /* This is an example of how to use libpng to read and write PNG files.
The file libpng.txt is much more verbose then this. If you have not * The file libpng.txt is much more verbose then this. If you have not
read it, do so first. This was designed to be a starting point of an * read it, do so first. This was designed to be a starting point of an
implementation. This is not officially part of libpng, and therefore * implementation. This is not officially part of libpng, and therefore
does not require a copyright notice. * does not require a copyright notice.
*
This file does not currently compile, because it is missing certain * This file does not currently compile, because it is missing certain
parts, like allocating memory to hold an image. You will have to * parts, like allocating memory to hold an image. You will have to
supply these parts to get it to compile. For an example of a minimal * supply these parts to get it to compile. For an example of a minimal
working PNG reader/writer, see pngtest.c, included in this distribution. * working PNG reader/writer, see pngtest.c, included in this distribution.
*/ */
#include <png.h> #include <png.h>
/* Check to see if a file is a PNG file using png_check_sig(). Returns /* Check to see if a file is a PNG file using png_check_sig(). Returns
non-zero if the image is a PNG, and 0 if it isn't a PNG. * non-zero if the image is a PNG, and 0 if it isn't a PNG.
*
If this call is successful, and you are going to keep the file open, * If this call is successful, and you are going to keep the file open,
you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once
you have created the png_ptr, so that libpng knows your application * you have created the png_ptr, so that libpng knows your application
has read that many bytes from the start of the file. Make sure you * has read that many bytes from the start of the file. Make sure you
don't call png_set_sig_bytes() with more than 8 bytes read or give it * don't call png_set_sig_bytes() with more than 8 bytes read or give it
an incorrect number of bytes read, or you will either have read too * an incorrect number of bytes read, or you will either have read too
many bytes (your fault), or you are telling libpng to read the wrong * many bytes (your fault), or you are telling libpng to read the wrong
number of magic bytes (also your fault). * number of magic bytes (also your fault).
*
Many applications already read the first 2 or 4 bytes from the start * Many applications already read the first 2 or 4 bytes from the start
of the image to determine the file type, so it would be easiest just * of the image to determine the file type, so it would be easiest just
to pass the bytes to png_check_sig() or even skip that if you know * to pass the bytes to png_check_sig() or even skip that if you know
you have a PNG file, and call png_set_sig_bytes(). * you have a PNG file, and call png_set_sig_bytes().
*/ */
#define PNG_BYTES_TO_CHECK 4 #define PNG_BYTES_TO_CHECK 4
int check_if_png(char *file_name, FILE **fp) int check_if_png(char *file_name, FILE **fp)
{ {
@ -49,10 +49,11 @@ int check_if_png(char *file_name, FILE **fp)
} }
/* Read a PNG file. You may want to return an error code if the read /* Read a PNG file. You may want to return an error code if the read
fails (depending upon the failure). There are two "prototypes" given * fails (depending upon the failure). There are two "prototypes" given
here - one where we are given the filename, and we need to open the * here - one where we are given the filename, and we need to open the
file, and the other where we are given an open file (possibly with * file, and the other where we are given an open file (possibly with
some or all of the magic bytes read - see comments above). */ * some or all of the magic bytes read - see comments above).
*/
**** prototype 1 **** **** prototype 1 ****
void read_png(char *file_name) /* We need to open the file */ void read_png(char *file_name) /* We need to open the file */
{ {
@ -118,7 +119,8 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
**** PNG file I/O method 2 **** **** PNG file I/O method 2 ****
/* If you are using replacement read functions, instead of calling /* If you are using replacement read functions, instead of calling
* png_init_io() here you would call */ * png_init_io() here you would call:
*/
png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn); png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
/* where user_io_ptr is a structure you want available to the callbacks */ /* where user_io_ptr is a structure you want available to the callbacks */
**** Use only one I/O method! **** **** Use only one I/O method! ****
@ -143,29 +145,31 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
/* tell libpng to strip 16 bit/color files down to 8 bits/color */ /* tell libpng to strip 16 bit/color files down to 8 bits/color */
png_set_strip_16(png_ptr); png_set_strip_16(png_ptr);
/* strip alpha bytes from the input data without combining with th /* Strip alpha bytes from the input data without combining with th
* background (not recommended) */ * background (not recommended).
*/
png_set_strip_alpha(png_ptr); png_set_strip_alpha(png_ptr);
/* extract multiple pixels with bit depths of 1, 2, and 4 from a single /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
* byte into separate bytes (useful for paletted and grayscale images). * byte into separate bytes (useful for paletted and grayscale images).
*/ */
png_set_packing(png_ptr); png_set_packing(png_ptr);
/* change the order of packed pixels to least significant bit first /* Change the order of packed pixels to least significant bit first
* (not useful if you are using png_set_packing). */ * (not useful if you are using png_set_packing). */
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
/* expand paletted colors into true RGB triplets */ /* Expand paletted colors into true RGB triplets */
if (color_type == PNG_COLOR_TYPE_PALETTE) if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_expand(png_ptr); png_set_expand(png_ptr);
/* expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */ /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
png_set_expand(png_ptr); png_set_expand(png_ptr);
/* expand paletted or RGB images with transparency to full alpha channels /* Expand paletted or RGB images with transparency to full alpha channels
* so the data will be available as RGBA quartets */ * so the data will be available as RGBA quartets.
*/
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
png_set_expand(png_ptr); png_set_expand(png_ptr);
@ -207,13 +211,17 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
* by the user at run time by the user. It is strongly suggested that * by the user at run time by the user. It is strongly suggested that
* your application support gamma correction. * your application support gamma correction.
*/ */
if (png_get_gAMA(png_ptr, info_ptr, &image_gamma); if (png_get_sRGB(png_ptr, info_ptr, &srgb_intent)
png_set_gamma(png_ptr, screen_gamma, image_gamma); png_set_sRGB(png_ptr, srgb_intent, 0);
else else
png_set_gamma(png_ptr, screen_gamma, 0.45); if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)
png_set_gamma(png_ptr, screen_gamma, image_gamma);
else
png_set_gamma(png_ptr, screen_gamma, 0.45);
/* Dither RGB files down to 8 bit palette or reduce palettes /* Dither RGB files down to 8 bit palette or reduce palettes
to the number of colors available on your screen */ * to the number of colors available on your screen.
*/
if (color_type & PNG_COLOR_MASK_COLOR) if (color_type & PNG_COLOR_MASK_COLOR)
{ {
png_uint_32 num_palette; png_uint_32 num_palette;
@ -269,19 +277,19 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
/* Turn on interlace handling. REQUIRED if you are not using /* Turn on interlace handling. REQUIRED if you are not using
* png_read_image(). To see how to handle interlacing passes, * png_read_image(). To see how to handle interlacing passes,
* see the png_read_row() method below. * see the png_read_row() method below:
*/ */
number_passes = png_set_interlace_handling(png_ptr); number_passes = png_set_interlace_handling(png_ptr);
/* optional call to gamma correct and add the background to the palette /* Optional call to gamma correct and add the background to the palette
* and update info structure. REQUIRED if you are expecting libpng to * and update info structure. REQUIRED if you are expecting libpng to
* update the palette for you (ie you selected such a transform above). * update the palette for you (ie you selected such a transform above).
*/ */
png_read_update_info(png_ptr, info_ptr); png_read_update_info(png_ptr, info_ptr);
/* allocate the memory to hold the image using the fields of info_ptr. */ /* Allocate the memory to hold the image using the fields of info_ptr. */
/* the easiest way to read the image */ /* The easiest way to read the image: */
png_bytep row_pointers[height]; png_bytep row_pointers[height];
for (row = 0; row < height; row++) for (row = 0; row < height; row++)
@ -294,7 +302,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
png_read_image(png_ptr, row_pointers); png_read_image(png_ptr, row_pointers);
**** Read the image one or more scanlines at a time **** **** Read the image one or more scanlines at a time ****
/* the other way to read images - deal with interlacing */ /* The other way to read images - deal with interlacing: */
for (pass = 0; pass < number_passes; pass++) for (pass = 0; pass < number_passes; pass++)
{ {
@ -552,7 +560,8 @@ void write_png(char *file_name, ... other image information ...)
/* Optional gamma chunk is strongly suggested if you have any guess /* Optional gamma chunk is strongly suggested if you have any guess
* as to the correct gamma of the image. */ * as to the correct gamma of the image.
*/
png_set_gAMA(png_ptr, info_ptr, gamma); png_set_gAMA(png_ptr, info_ptr, gamma);
/* Optionally write comments into the image */ /* Optionally write comments into the image */
@ -568,6 +577,8 @@ void write_png(char *file_name, ... other image information ...)
png_set_text(png_ptr, info_ptr, text_ptr, 2); png_set_text(png_ptr, info_ptr, text_ptr, 2);
/* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */ /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
/* note that if sRGB is present the cHRM chunk must be ignored
* on read and must be written in accordance with the sRGB profile */
/* Write the file header information. REQUIRED */ /* Write the file header information. REQUIRED */
png_write_info(png_ptr, info_ptr); png_write_info(png_ptr, info_ptr);
@ -579,13 +590,15 @@ void write_png(char *file_name, ... other image information ...)
*/ */
/* 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. */ * all optional. Only call them if you want them.
*/
/* invert monocrome pixels */ /* invert monocrome pixels */
png_set_invert(png_ptr); png_set_invert(png_ptr);
/* Shift the pixels up to a legal bit depth and fill in /* Shift the pixels up to a legal bit depth and fill in
* as appropriate to correctly scale the image */ * as appropriate to correctly scale the image.
*/
png_set_shift(png_ptr, &sig_bit); png_set_shift(png_ptr, &sig_bit);
/* pack pixels into bytes */ /* pack pixels into bytes */
@ -595,7 +608,8 @@ void write_png(char *file_name, ... other image information ...)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
* RGB (4 channels -> 3 channels). The second parameter is not used. */ * RGB (4 channels -> 3 channels). The second parameter is not used.
*/
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
/* flip BGR pixels to RGB */ /* flip BGR pixels to RGB */

51
libpng.txt
View File

@ -1,10 +1,13 @@
libpng.txt - a description on how to use and modify libpng libpng.txt - a description on how to use and modify libpng
libpng 1.0 beta 5 - version 0.95 libpng version 1.00 version 0.97
based on:
libpng version 1.00 version 0.96
Updated and distributed by Andreas Dilger <adilger@enel.ucalgary.ca>, Updated and distributed by Andreas Dilger <adilger@enel.ucalgary.ca>,
Copyright (c) 1996, 1997 Andreas Dilger Copyright (c) 1996, 1997 Andreas Dilger
March 15, 1997 May 28, 1997
based on:
libpng 1.0 beta 2 - version 0.88 libpng 1.0 beta 2 - version 0.88
For conditions of distribution and use, see copyright notice in png.h For conditions of distribution and use, see copyright notice in png.h
@ -27,11 +30,18 @@ will need.
Libpng was written as a companion to the PNG specification, as a way Libpng was written as a companion to the PNG specification, as a way
to reduce the amount of time and effort it takes to support the PNG to reduce the amount of time and effort it takes to support the PNG
file format in application programs. Most users will not have to file format in application programs. The PNG specification is available
modify the library significantly; advanced users may want to modify it as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/> and as a
more. All attempts were made to make it as complete as possible, W3C Recommendation <http://www.w3.org/pub/WWW/TR/REC.png.html>. Some
while keeping the code easy to understand. Currently, this library additional chunks are described in the special-purpose public chunks
only supports C. Support for other languages is being considered. documents at <ftp://ftp.uu.net/graphics/png/documents/>. Other information
about PNG can be found at the PNG home page, <http://www.cdrom.com/pub/png/>.
Most users will not have to modify the library significantly; advanced
users may want to modify it more. All attempts were made to make it as
complete as possible, while keeping the code easy to understand.
Currently, this library only supports C. Support for other languages
is being considered.
Libpng has been designed to handle multiple sessions at one time, Libpng has been designed to handle multiple sessions at one time,
to be easily modifiable, to be portable to the vast majority of to be easily modifiable, to be portable to the vast majority of
@ -341,7 +351,7 @@ transparency information in a tRNS chunk. This is most useful on
grayscale images with bit depths of 2 or 4 or if there is a multiple-image grayscale images with bit depths of 2 or 4 or if there is a multiple-image
viewing application that wishes to treat all images in the same way. viewing application that wishes to treat all images in the same way.
if (color_type == PNG_COLOR_TYPE_PALETTE && bit_depth < 8) if (color_type == PNG_COLOR_TYPE_PALETTE && bit_depth <= 8)
png_set_expand(png_ptr); png_set_expand(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
@ -614,7 +624,7 @@ The first pass will return an image 1/8 as wide as the entire image
(every 8th column starting in column 0) and 1/8 as high as the original (every 8th column starting in column 0) and 1/8 as high as the original
(every 8th row starting in row 0), the second will be 1/8 as wide (every 8th row starting in row 0), the second will be 1/8 as wide
(starting in column 4) and 1/8 as high (also starting in row 0). The (starting in column 4) and 1/8 as high (also starting in row 0). The
third pass will be 1/4 as wide (every 4th pixel starting in row 0) and third pass will be 1/4 as wide (every 4th pixel starting in column 0) and
1/8 as high (every 8th row starting in row 4), and the fourth pass will 1/8 as high (every 8th row starting in row 4), and the fourth pass will
be 1/4 as wide and 1/4 as high (every 4th column starting in column 2, be 1/4 as wide and 1/4 as high (every 4th column starting in column 2,
and every 4th row starting in row 0). The fifth pass will return an and every 4th row starting in row 0). The fifth pass will return an
@ -1013,7 +1023,8 @@ The keywords that are given in the PNG Specification are:
Author Name of image's creator Author Name of image's creator
Description Description of image (possibly long) Description Description of image (possibly long)
Copyright Copyright notice Copyright Copyright notice
Creation Time Time of original image creation Creation Time Time of original image creation (usually
RFC 1123 format, see below)
Software Software used to create the image Software Software used to create the image
Disclaimer Legal disclaimer Disclaimer Legal disclaimer
Warning Warning of nature of content Warning Warning of nature of content
@ -1050,6 +1061,20 @@ instead of your local time. Note that the year number is the full
year (ie 1996, rather than 96 - PNG is year 2000 compliant!), and year (ie 1996, rather than 96 - PNG is year 2000 compliant!), and
that months start with 1. that months start with 1.
If you want to store the time of the original image creation, you should
use a plain tEXt chunk with the "Creation Time" keyword. This is
necessary because the "creation time" of a PNG image is somewhat vague,
depending on whether you mean the PNG file, the time the image was
created in a non-PNG format, a still photo from which the image was
scanned, or possibly the subject matter itself. In order to facilitate
machine-readable dates, it is recommended that the "Creation Time"
tEXt chunk use RFC 1123 format dates (eg 22 May 1997 18:07:10 GMT"),
although this isn't a requirement. Unlike the tIME chunk, the
"Creation Time" tEXt chunk is not expected to be automatically changed
by the software. To facilitate the use of RFC 1123 dates, a function
png_convert_to_rfc1152(png_timep) is provided to convert from PNG
time to an RFC 1152 format string.
You are now ready to write all the file information up to the actual You are now ready to write all the file information up to the actual
image data. You do this with a call to png_write_info(). image data. You do this with a call to png_write_info().
@ -1307,8 +1332,8 @@ default function will be used, calling fprintf() and/or longjmp() if a
problem is encountered. The replacement error functions should have problem is encountered. The replacement error functions should have
parameters as follows: parameters as follows:
void user_error_fn(png_struct png_ptr, png_const_charp error_msg); void user_error_fn(png_structp png_ptr, png_const_charp error_msg);
void user_warning_fn(png_struct png_ptr, png_const_charp warning_msg); void user_warning_fn(png_structp png_ptr, png_const_charp warning_msg);
The motivation behind using setjmp() and longjmp() is the C++ throw and The motivation behind using setjmp() and longjmp() is the C++ throw and
catch exception handling methods. This makes the code much easier to write, catch exception handling methods. This makes the code much easier to write,

68
makefile.dec Normal file
View File

@ -0,0 +1,68 @@
# makefile for libpng on DEC Alpha Unix
# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
# For conditions of distribution and use, see copyright notice in png.h
# Where the zlib library and include files are located
#ZLIBLIB=/usr/local/lib
#ZLIBINC=/usr/local/include
ZLIBLIB=../zlib
ZLIBINC=../zlib
CC=cc
CFLAGS=-std -w1 -I$(ZLIBINC) -O # -g -DPNG_DEBUG=1
LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
#RANLIB=echo
RANLIB=ranlib
# where make install puts libpng.a and png.h
prefix=/usr/local
OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
pngwtran.o pngmem.o pngerror.o pngpread.o
all: libpng.a pngtest
libpng.a: $(OBJS)
ar rc $@ $(OBJS)
$(RANLIB) $@
pngtest: pngtest.o libpng.a
$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
test: pngtest
./pngtest
install: libpng.a
-@mkdir $(prefix)/include
-@mkdir $(prefix)/lib
cp png.h $(prefix)/include
cp pngconf.h $(prefix)/include
chmod 644 $(prefix)/include/png.h
chmod 644 $(prefix)/include/pngconf.h
cp libpng.a $(prefix)/lib
chmod 644 $(prefix)/lib/libpng.a
clean:
rm -f *.o libpng.a pngtest pngout.png
# DO NOT DELETE THIS LINE -- make depend depends on it.
png.o: png.h pngconf.h
pngerror.o: png.h pngconf.h
pngrio.o: png.h pngconf.h
pngwio.o: png.h pngconf.h
pngmem.o: png.h pngconf.h
pngset.o: png.h pngconf.h
pngget.o: png.h pngconf.h
pngread.o: png.h pngconf.h
pngrtran.o: png.h pngconf.h
pngrutil.o: png.h pngconf.h
pngtest.o: png.h pngconf.h
pngtrans.o: png.h pngconf.h
pngwrite.o: png.h pngconf.h
pngwtran.o: png.h pngconf.h
pngwutil.o: png.h pngconf.h
pngpread.o: png.h pngconf.h

10
makefile.elf
View File

@ -13,14 +13,14 @@ ZLIBINC=../zlib
WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \ WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
-Wmissing-declarations -Wtraditional -Wcast-align \ -Wmissing-declarations -Wtraditional -Wcast-align \
-Wstrict-prototypes -Wmissing-prototypes #-Wconversion -Wstrict-prototypes -Wmissing-prototypes #-Wconversion
CFLAGS=-I$(ZLIBINC) -Wall -O2 -fPIC # $(WARNMORE) # -g -DPNG_DEBUG=3 CFLAGS=-I$(ZLIBINC) -Wall -O3 -funroll-loops -malign-loops=2 -malign-functions=2 -fPIC #$(WARNMORE) -g -DPNG_DEBUG=5
LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm
RANLIB=ranlib RANLIB=ranlib
#RANLIB=echo #RANLIB=echo
PNGMAJ = 0 PNGMAJ = 1
PNGMIN = 96 PNGMIN = 1.0
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# where make install puts libpng.a, libpng.so*, and png.h # where make install puts libpng.a, libpng.so*, and png.h
@ -45,10 +45,10 @@ libpng.so.$(PNGMAJ): libpng.so.$(PNGVER)
ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ) ln -sf libpng.so.$(PNGVER) libpng.so.$(PNGMAJ)
libpng.so.$(PNGVER): $(OBJS) libpng.so.$(PNGVER): $(OBJS)
gcc -shared -Wl,-soname,libpng.so.$(PNGMAJ) -o libpng.so.$(PNGVER) $(OBJS) gcc -shared -Wl,-soname,libpng.so.$(PNGMAJ) $(OBJS) -o libpng.so.$(PNGVER)
pngtest: pngtest.o libpng.so pngtest: pngtest.o libpng.so
$(CC) -o pngtest pngtest.o $(LDFLAGS) $(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
test: pngtest test: pngtest
./pngtest ./pngtest

154
png.c
View File

@ -1,27 +1,29 @@
/* png.c - location for general purpose png functions /* png.c - location for general purpose libpng functions
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
#define PNG_INTERNAL #define PNG_INTERNAL
#define PNG_NO_EXTERN #define PNG_NO_EXTERN
#include "png.h" #include "png.h"
/* Version information for C files. This had better match the version /* Version information for C files. This had better match the version
string defined in png.h */ * string defined in png.h.
char png_libpng_ver[] = "0.95"; */
char png_libpng_ver[] = "1.00.97";
/* Place to hold the signiture string for a PNG file. */ /* Place to hold the signiture string for a PNG file. */
png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
/* constant strings for known chunk types. If you need to add a chunk, /* Constant strings for known chunk types. If you need to add a chunk,
add a string holding the name here. If you want to make the code * add a string holding the name here. If you want to make the code
portable to EBCDIC machines, use ASCII numbers, not characters. */ * portable to EBCDIC machines, use ASCII numbers, not characters.
*/
png_byte FARDATA png_IHDR[5] = { 73, 72, 68, 82, '\0'}; png_byte FARDATA png_IHDR[5] = { 73, 72, 68, 82, '\0'};
png_byte FARDATA png_IDAT[5] = { 73, 68, 65, 84, '\0'}; png_byte FARDATA png_IDAT[5] = { 73, 68, 65, 84, '\0'};
png_byte FARDATA png_IEND[5] = { 73, 69, 78, 68, '\0'}; png_byte FARDATA png_IEND[5] = { 73, 69, 78, 68, '\0'};
@ -34,6 +36,7 @@ png_byte FARDATA png_oFFs[5] = {111, 70, 70, 115, '\0'};
png_byte FARDATA png_pCAL[5] = {112, 67, 65, 76, '\0'}; png_byte FARDATA png_pCAL[5] = {112, 67, 65, 76, '\0'};
png_byte FARDATA png_pHYs[5] = {112, 72, 89, 115, '\0'}; png_byte FARDATA png_pHYs[5] = {112, 72, 89, 115, '\0'};
png_byte FARDATA png_sBIT[5] = {115, 66, 73, 84, '\0'}; png_byte FARDATA png_sBIT[5] = {115, 66, 73, 84, '\0'};
png_byte FARDATA png_sRGB[5] = {115, 82, 71, 66, '\0'};
png_byte FARDATA png_tEXt[5] = {116, 69, 88, 116, '\0'}; png_byte FARDATA png_tEXt[5] = {116, 69, 88, 116, '\0'};
png_byte FARDATA png_tIME[5] = {116, 73, 77, 69, '\0'}; png_byte FARDATA png_tIME[5] = {116, 73, 77, 69, '\0'};
png_byte FARDATA png_tRNS[5] = {116, 82, 78, 83, '\0'}; png_byte FARDATA png_tRNS[5] = {116, 82, 78, 83, '\0'};
@ -53,22 +56,20 @@ int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
/* offset to next interlace block in the y direction */ /* offset to next interlace block in the y direction */
int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
/* width of interlace block */ /* Width of interlace block. This is not currently used - if you need
/* this is not currently used - if you need it, uncomment it here and * it, uncomment it here and in png.h
in png.h
int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
*/ */
/* height of interlace block */ /* Height of interlace block. This is not currently used - if you need
/* this is not currently used - if you need it, uncomment it here and * it, uncomment it here and in png.h
in png.h
int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
*/ */
/* mask to determine which pixels are valid in a pass */ /* Mask to determine which pixels are valid in a pass */
int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
/* mask to determine which pixels to overwrite while displaying */ /* Mask to determine which pixels to overwrite while displaying */
int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
@ -113,8 +114,9 @@ png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
} }
/* (Obsolete) function to check signature bytes. It does not allow one /* (Obsolete) function to check signature bytes. It does not allow one
to check a partial signature. This function will be removed in the * to check a partial signature. This function will be removed in the
future - use png_sig_cmp(). */ * future - use png_sig_cmp().
*/
int int
png_check_sig(png_bytep sig, int num) png_check_sig(png_bytep sig, int num)
{ {
@ -151,78 +153,19 @@ png_zfree(voidpf png_ptr, voidpf ptr)
} }
/* Reset the CRC variable to 32 bits of 1's. Care must be taken /* Reset the CRC variable to 32 bits of 1's. Care must be taken
in case CRC is > 32 bits to leave the top bits 0. */ * in case CRC is > 32 bits to leave the top bits 0.
*/
void void
png_reset_crc(png_structp png_ptr) png_reset_crc(png_structp png_ptr)
{ {
/* set CRC to all 1's */
#ifdef PNG_USE_OWN_CRC
png_ptr->crc = 0xffffffffL;
#else
png_ptr->crc = crc32(0, Z_NULL, 0); png_ptr->crc = crc32(0, Z_NULL, 0);
#endif
} }
#ifdef PNG_USE_OWN_CRC
/* Table of CRCs of all 8-bit messages. By default, we use the tables made
by zlib, to save some memory. If you wish to png_malloc() this
table, turn this into a pointer, and png_malloc() it in make_crc_table().
You may then want to hook it into png_struct and free it with the
destroy functions. Another alternative is to pre-fill the table. */
static png_uint_32 crc_table[256];
/* Flag: has the table been computed? Initially false. */
static int crc_table_computed = 0;
/* make the table for a fast crc */
static void
make_crc_table(void)
{
png_uint_32 c;
int n, k;
for (n = 0; n < 256; n++)
{
c = (png_uint_32)n;
for (k = 0; k < 8; k++)
c = c & 1 ? 0xedb88320L ^ (c >> 1) : c >> 1;
crc_table[n] = c;
}
crc_table_computed = 1;
}
/* Update a running CRC with the bytes buf[0..len-1] - the CRC should be
initialized to all 1's, and the transmitted value is the 1's complement
of the final running CRC. */
static png_uint_32
update_crc(png_uint_32 crc, png_bytep buf, png_size_t len)
{
png_uint_32 c;
png_bytep p;
png_uint_32 n;
c = crc;
p = buf;
n = len;
if (!crc_table_computed)
{
make_crc_table();
}
if (n > 0) do
{
c = crc_table[(png_byte)((c ^ (*p++)) & 0xff)] ^ (c >> 8);
} while (--n);
return c;
}
#endif /* PNG_USE_OWN_CRC */
/* Calculate the CRC over a section of data. We can only pass as /* Calculate the CRC over a section of data. We can only pass as
much data to this routine as the largest single buffer size. We * much data to this routine as the largest single buffer size. We
also check that this data will actually be used before going to the * also check that this data will actually be used before going to the
trouble of calculating it. */ * trouble of calculating it.
*/
void void
png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
{ {
@ -241,18 +184,15 @@ png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
} }
if (need_crc) if (need_crc)
#ifdef PNG_USE_OWN_CRC
png_ptr->crc = update_crc(png_ptr->crc, ptr, length);
#else
png_ptr->crc = crc32(png_ptr->crc, ptr, length); png_ptr->crc = crc32(png_ptr->crc, ptr, length);
#endif
} }
/* Allocate the memory for an info_struct for the application. We don't /* Allocate the memory for an info_struct for the application. We don't
really need the png_ptr, but it could potentially be useful in the * really need the png_ptr, but it could potentially be useful in the
future. This should be used in favour of malloc(sizeof(png_info)) * future. This should be used in favour of malloc(sizeof(png_info))
and png_info_init() so that applications that want to use a shared * and png_info_init() so that applications that want to use a shared
libpng don't have to be recompiled if png_info changes size. */ * libpng don't have to be recompiled if png_info changes size.
*/
png_infop png_infop
png_create_info_struct(png_structp png_ptr) png_create_info_struct(png_structp png_ptr)
{ {
@ -268,9 +208,10 @@ png_create_info_struct(png_structp png_ptr)
} }
/* This function frees the memory associated with a single info struct. /* This function frees the memory associated with a single info struct.
Normally, one would use either png_destroy_read_struct() or * Normally, one would use either png_destroy_read_struct() or
png_destroy_write_struct() to free an info struct, but this may be * png_destroy_write_struct() to free an info struct, but this may be
useful for some applications. */ * useful for some applications.
*/
void void
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
{ {
@ -290,8 +231,9 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
} }
/* Initialize the info structure. This is now an internal function (0.89) /* Initialize the info structure. This is now an internal function (0.89)
and applications using it are urged to use png_create_info_struct() * and applications using it are urged to use png_create_info_struct()
instead. */ * instead.
*/
void void
png_info_init(png_infop info_ptr) png_info_init(png_infop info_ptr)
{ {
@ -337,8 +279,9 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
} }
/* This function returns a pointer to the io_ptr associated with the user /* This function returns a pointer to the io_ptr associated with the user
functions. The application should free any memory associated with this * functions. The application should free any memory associated with this
pointer before png_write_destroy() or png_read_destroy() are called. */ * pointer before png_write_destroy() or png_read_destroy() are called.
*/
png_voidp png_voidp
png_get_io_ptr(png_structp png_ptr) png_get_io_ptr(png_structp png_ptr)
{ {
@ -347,8 +290,9 @@ png_get_io_ptr(png_structp png_ptr)
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
/* Initialize the default input/output functions for the PNG file. If you /* Initialize the default input/output functions for the PNG file. If you
use your own read or write routines, you can call either png_set_read_fn() * use your own read or write routines, you can call either png_set_read_fn()
or png_set_write_fn() instead of png_init_io(). */ * or png_set_write_fn() instead of png_init_io().
*/
void void
png_init_io(png_structp png_ptr, FILE *fp) png_init_io(png_structp png_ptr, FILE *fp)
{ {

238
png.h
View File

@ -1,67 +1,71 @@
/* png.h - header file for PNG reference library /* png.h - header file for PNG reference library
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97 beta 7
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * Dec 31, 1997
*
BETA NOTICE: * BETA NOTICE:
This is a beta version. It reads and writes valid files on the * This is a beta version. It reads and writes valid files on the
platforms I have, and has had a wide testing program. You may * platforms I have, and has had a wide testing program. You may
have to modify the includes below to get it to work on your * have to modify the includes below to get it to work on your
system, and you may have to supply the correct compiler flags in * system, and you may have to supply the correct compiler flags in
the makefile if you can't find a makefile suitable for your * the makefile if you can't find a makefile suitable for your
operating system/compiler combination. Read libpng.txt for more * operating system/compiler combination. Read libpng.txt for more
information, including how to contact the authors if you have any * information, including how to contact the authors if you have any
problems, or if you want your compiler/platform to be supported in * problems, or if you want your compiler/platform to be supported in
the next official libpng release. * the next official libpng release.
*
See libpng.txt for more information. * See libpng.txt for more information. The PNG specification is available
* as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/>
Contributing Authors: * and as a W3C Recommendation <http://www.w3.org/pub/WWW/TR/REC.png.html>
John Bowler *
Sam Bushell * Contributing Authors:
Kevin Bracey * John Bowler
Andreas Dilger * Sam Bushell
Magnus Holmgren * Kevin Bracey
Dave Martindale * Andreas Dilger
Greg Roelofs * Magnus Holmgren
Guy Eric Schalnat * Tom Lane
Paul Schmidt * Dave Martindale
Tom Tanner * Glenn Randers-Pehrson
Tim Wegner * Greg Roelofs
* Guy Eric Schalnat
The contributing authors would like to thank all those who helped * Paul Schmidt
with testing, bug fixes, and patience. This wouldn't have been * Tom Tanner
possible without all of you. * Tim Wegner
*
Thanks to Frank J. T. Wojcik for helping with the documentation. * The contributing authors would like to thank all those who helped
* with testing, bug fixes, and patience. This wouldn't have been
The PNG Reference Library is supplied "AS IS". The Contributing Authors * possible without all of you.
and Group 42, Inc. disclaim all warranties, expressed or implied, *
including, without limitation, the warranties of merchantability and of * Thanks to Frank J. T. Wojcik for helping with the documentation.
fitness for any purpose. The Contributing Authors and Group 42, Inc. *
assume no liability for direct, indirect, incidental, special, exemplary, * The PNG Reference Library is supplied "AS IS". The Contributing Authors
or consequential damages, which may result from the use of the PNG * and Group 42, Inc. disclaim all warranties, expressed or implied,
Reference Library, even if advised of the possibility of such damage. * including, without limitation, the warranties of merchantability and of
* fitness for any purpose. The Contributing Authors and Group 42, Inc.
Permission is hereby granted to use, copy, modify, and distribute this * assume no liability for direct, indirect, incidental, special, exemplary,
source code, or portions hereof, for any purpose, without fee, subject * or consequential damages, which may result from the use of the PNG
to the following restrictions: * Reference Library, even if advised of the possibility of such damage.
1. The origin of this source code must not be misrepresented. *
2. Altered versions must be plainly marked as such and must not be * Permission is hereby granted to use, copy, modify, and distribute this
misrepresented as being the original source. * source code, or portions hereof, for any purpose, without fee, subject
3. This Copyright notice may not be removed or altered from any source or * to the following restrictions:
altered source distribution. * 1. The origin of this source code must not be misrepresented.
* 2. Altered versions must be plainly marked as such and must not be
The Contributing Authors and Group 42, Inc. specifically permit, without * misrepresented as being the original source.
fee, and encourage the use of this source code as a component to * 3. This Copyright notice may not be removed or altered from any source or
supporting the PNG file format in commercial products. If you use this * altered source distribution.
source code in a product, acknowledgment is not required but would be *
appreciated. * The Contributing Authors and Group 42, Inc. specifically permit, without
*/ * fee, and encourage the use of this source code as a component to
* supporting the PNG file format in commercial products. If you use this
* source code in a product, acknowledgment is not required but would be
* appreciated.
*/
#ifndef _PNG_H #ifndef _PNG_H
#define _PNG_H #define _PNG_H
@ -89,12 +93,12 @@ extern "C" {
*/ */
/* Version information for png.h - this should match the version in png.c */ /* Version information for png.h - this should match the version in png.c */
#define PNG_LIBPNG_VER_STRING "0.96" #define PNG_LIBPNG_VER_STRING "1.00.97"
/* careful here. At one time, I wanted to use 082, but that would be octal. /* careful here. At one time, I wanted to use 082, but that would be octal.
* Version 1.0 will be 100 here, etc. * Version 1.0 will be 100 here, etc.
*/ */
#define PNG_LIBPNG_VER 96 #define PNG_LIBPNG_VER 97
/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ /* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
#ifndef PNG_NO_EXTERN #ifndef PNG_NO_EXTERN
@ -172,10 +176,11 @@ typedef png_text FAR * FAR * png_textpp;
#define PNG_TEXT_COMPRESSION_LAST 1 /* Not a valid value */ #define PNG_TEXT_COMPRESSION_LAST 1 /* Not a valid value */
/* png_time is a way to hold the time in an machine independent way. /* png_time is a way to hold the time in an machine independent way.
Two conversions are provided, both from time_t and struct tm. There * Two conversions are provided, both from time_t and struct tm. There
is no portable way to convert to either of these structures, as far * is no portable way to convert to either of these structures, as far
as I know. If you know of a portable way, send it to me. As a side * as I know. If you know of a portable way, send it to me. As a side
note - PNG is Year 2000 compliant! */ * note - PNG is Year 2000 compliant!
*/
typedef struct png_time_struct typedef struct png_time_struct
{ {
png_uint_16 year; /* full year, as in, 1995 */ png_uint_16 year; /* full year, as in, 1995 */
@ -244,6 +249,13 @@ typedef struct png_info_struct
*/ */
float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */
#endif /* PNG_READ_gAMA_SUPPORTED || PNG_WRITE_gAMA_SUPPORTED */ #endif /* PNG_READ_gAMA_SUPPORTED || PNG_WRITE_gAMA_SUPPORTED */
#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
/* GR-P, 0.96a */
/* Data valid if (valid & PNG_INFO_sRGB) non-zero. */
png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */
#endif /* PNG_READ_sRGB_SUPPORTED || PNG_WRITE_sRGB_SUPPORTED */
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
/* The tEXt and zTXt chunks contain human-readable textual data in /* The tEXt and zTXt chunks contain human-readable textual data in
@ -422,6 +434,7 @@ typedef png_info FAR * FAR * png_infopp;
#define PNG_INFO_oFFs 0x0100 #define PNG_INFO_oFFs 0x0100
#define PNG_INFO_tIME 0x0200 #define PNG_INFO_tIME 0x0200
#define PNG_INFO_pCAL 0x0400 #define PNG_INFO_pCAL 0x0400
#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */
/* This is used for the transformation routines, as some of them /* This is used for the transformation routines, as some of them
* change these values for the row. It also should enable using * change these values for the row. It also should enable using
@ -524,7 +537,6 @@ struct png_struct_def
png_byte usr_channels; /* channels at start of write */ png_byte usr_channels; /* channels at start of write */
png_byte sig_bytes; /* magic bytes read/written from start of file */ png_byte sig_bytes; /* magic bytes read/written from start of file */
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
png_byte filler; /* filler byte for 24->32-bit pixel expansion */ png_byte filler; /* filler byte for 24->32-bit pixel expansion */
#endif /* PNG_READ_FILLER_SUPPORTED */ #endif /* PNG_READ_FILLER_SUPPORTED */
@ -609,6 +621,9 @@ struct png_struct_def
png_uint_16p filter_costs; /* relative filter calculation cost */ png_uint_16p filter_costs; /* relative filter calculation cost */
png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
#if defined(PNG_TIME_RFC1152_SUPPORTED)
png_charp time_buffer; /* String to hold RFC 1152 time text */
#endif /* PNG_TIME_RFC1152_SUPPORTED */
}; };
typedef png_struct FAR * FAR * png_structpp; typedef png_struct FAR * FAR * png_structpp;
@ -640,8 +655,8 @@ extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num));
/* Allocate and initialize png_ptr struct for reading, and any other memory. */ /* Allocate and initialize png_ptr struct for reading, and any other memory. */
extern PNG_EXPORT(png_structp,png_create_read_struct) extern PNG_EXPORT(png_structp,png_create_read_struct)
PNGARG((png_charp user_png_ver, voidp error_ptr, png_error_ptr error_fn, PNGARG((png_const_charp user_png_ver, voidp error_ptr,
png_error_ptr warn_fn)); png_error_ptr error_fn, png_error_ptr warn_fn));
/* Allocate and initialize png_ptr struct for reading, and any other memory */ /* Allocate and initialize png_ptr struct for reading, and any other memory */
extern PNG_EXPORT(png_structp,png_create_write_struct) extern PNG_EXPORT(png_structp,png_create_write_struct)
@ -663,6 +678,11 @@ extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,
extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,
png_infop info_ptr)); png_infop info_ptr));
#if defined(PNG_TIME_RFC1152_SUPPORTED)
extern PNG_EXPORT(png_charp,png_convert_to_rfc1152)
PNGARG((png_structp png_ptr, png_timep ptime));
#endif /* PNG_TIME_RFC1152_SUPPORTED */
#if defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_WRITE_tIME_SUPPORTED)
/* convert from a struct tm to png_time */ /* convert from a struct tm to png_time */
extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,
@ -840,6 +860,9 @@ extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,
extern PNG_EXPORT(void,png_destroy_write_struct) extern PNG_EXPORT(void,png_destroy_write_struct)
PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));
/* free any memory used in info_ptr struct (old method - NOT DLL EXPORTED) */
extern void png_write_destroy_info PNGARG((png_infop info_ptr));
/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ /* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */
extern void png_write_destroy PNGARG((png_structp png_ptr)); extern void png_write_destroy PNGARG((png_structp png_ptr));
@ -868,10 +891,12 @@ extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,
* mainly useful for testing, as the defaults should work with most users. * mainly useful for testing, as the defaults should work with most users.
* Those users who are tight on memory or want faster performance at the * Those users who are tight on memory or want faster performance at the
* expense of compression can modify them. See the compression library * expense of compression can modify them. See the compression library
* header file (zlib.h) for an explination of the compression functions. */ * header file (zlib.h) for an explination of the compression functions.
*/
/* set the filtering method(s) used by libpng. Currently, the only valid /* set the filtering method(s) used by libpng. Currently, the only valid
* value for "method" is 0 */ * value for "method" is 0.
*/
extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,
int filters)); int filters));
@ -1030,7 +1055,7 @@ extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,
extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,
png_uint_32 size)); png_uint_32 size));
/* free's a pointer allocated by png_malloc() */ /* frees a pointer allocated by png_malloc() */
extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));
#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ #if defined(USE_FAR_KEYWORD) /* memory model conversion function */
@ -1175,6 +1200,18 @@ extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,
png_infop info_ptr, png_color_8p sig_bit)); png_infop info_ptr, png_color_8p sig_bit));
#endif /* PNG_READ_sBIT_SUPPORTED || PNG_WRITE_sBIT_SUPPORTED */ #endif /* PNG_READ_sBIT_SUPPORTED || PNG_WRITE_sBIT_SUPPORTED */
#if defined(PNG_READ_sRGB_SUPPORTED)
extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,
png_infop info_ptr, png_byte *srgb_intent));
#endif /* PNG_READ_sRGB_SUPPORTED */
#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,
png_infop info_ptr, png_byte srgb_intent));
extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,
png_infop info_ptr, png_byte srgb_intent));
#endif /* PNG_READ_sRGB_SUPPORTED || PNG_WRITE_sRGB_SUPPORTED */
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED) #if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
/* png_get_text also returns the number of text chunks in text_ptr */ /* png_get_text also returns the number of text chunks in text_ptr */
extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,
@ -1244,13 +1281,17 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
#if defined(PNG_INTERNAL) #if defined(PNG_INTERNAL)
/* Various modes of operation. Note that after an init, mode is set to /* Various modes of operation. Note that after an init, mode is set to
zero automatically when the structure is created. */ * zero automatically when the structure is created.
*/
#define PNG_BEFORE_IHDR 0x00 #define PNG_BEFORE_IHDR 0x00
#define PNG_HAVE_IHDR 0x01 #define PNG_HAVE_IHDR 0x01
#define PNG_HAVE_PLTE 0x02 #define PNG_HAVE_PLTE 0x02
#define PNG_HAVE_IDAT 0x04 #define PNG_HAVE_IDAT 0x04
#define PNG_AFTER_IDAT 0x08 #define PNG_AFTER_IDAT 0x08
#define PNG_HAVE_IEND 0x10 #define PNG_HAVE_IEND 0x10
#define PNG_HAVE_gAMA 0x20
#define PNG_HAVE_cHRM 0x40
#define PNG_HAVE_sRGB 0x80
/* push model modes */ /* push model modes */
#define PNG_READ_SIG_MODE 0 #define PNG_READ_SIG_MODE 0
@ -1331,10 +1372,11 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
/* place to hold the signiture string for a PNG file. */ /* place to hold the signiture string for a PNG file. */
extern png_byte FARDATA png_sig[]; extern png_byte FARDATA png_sig[];
/* constant strings for known chunk types. If you need to add a chunk, /* Constant strings for known chunk types. If you need to add a chunk,
add a string holding the name here. See png.c for more details. We * add a string holding the name here. See png.c for more details. We
can't selectively include these, since we still check for chunk in the * can't selectively include these, since we still check for chunk in the
wrong locations with these labels. */ * wrong locations with these labels.
*/
extern png_byte FARDATA png_IHDR[]; extern png_byte FARDATA png_IHDR[];
extern png_byte FARDATA png_IDAT[]; extern png_byte FARDATA png_IDAT[];
extern png_byte FARDATA png_IEND[]; extern png_byte FARDATA png_IEND[];
@ -1347,6 +1389,7 @@ extern png_byte FARDATA png_oFFs[];
extern png_byte FARDATA png_pCAL[]; extern png_byte FARDATA png_pCAL[];
extern png_byte FARDATA png_pHYs[]; extern png_byte FARDATA png_pHYs[];
extern png_byte FARDATA png_sBIT[]; extern png_byte FARDATA png_sBIT[];
extern png_byte FARDATA png_sRGB[];
extern png_byte FARDATA png_tEXt[]; extern png_byte FARDATA png_tEXt[];
extern png_byte FARDATA png_tIME[]; extern png_byte FARDATA png_tIME[];
extern png_byte FARDATA png_tRNS[]; extern png_byte FARDATA png_tRNS[];
@ -1376,12 +1419,14 @@ PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf));
PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf)); PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf));
#endif /* PNG_BIG_ENDIAN_GET_SUPPORTED */ #endif /* PNG_BIG_ENDIAN_GET_SUPPORTED */
/* Initialize png_ptr struct for reading, and allocate any other memory /* Initialize png_ptr struct for reading, and allocate any other memory.
* (old interface - NOT DLL EXPORTED) */ * (old interface - NOT DLL EXPORTED).
*/
extern void png_read_init PNGARG((png_structp png_ptr)); extern void png_read_init PNGARG((png_structp png_ptr));
/* Initialize png_ptr struct for writing, and allocate any other memory /* Initialize png_ptr struct for writing, and allocate any other memory.
* (old interface - NOT DLL EXPORTED) */ * (old interface - NOT DLL EXPORTED).
*/
extern void png_write_init PNGARG((png_structp png_ptr)); extern void png_write_init PNGARG((png_structp png_ptr));
/* allocate memory for an internal libpng struct */ /* allocate memory for an internal libpng struct */
@ -1433,7 +1478,7 @@ PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
#endif #endif
/* Place a 32-bit number into a buffer in PNG byte order (big-endian). /* Place a 32-bit number into a buffer in PNG byte order (big-endian).
* The only currently known PNG chunk that uses unsigned numbers is * The only currently known PNG chunk that uses signed numbers is
* the ancillary extension chunk, pCAL. * the ancillary extension chunk, pCAL.
*/ */
PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i)); PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i));
@ -1442,8 +1487,11 @@ PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i));
PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i)); PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i));
#endif #endif
/* place a 16 bit number into a buffer in PNG byte order */ /* Place a 16 bit number into a buffer in PNG byte order.
PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, png_uint_16 i)); * The parameter is declared unsigned int, not png_uint_16,
* just to avoid potential problems on pre-ANSI C compilers.
*/
PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i));
/* Write a PNG chunk - size, type, (optional) data, CRC. */ /* Write a PNG chunk - size, type, (optional) data, CRC. */
PNG_EXTERN void png_write_chunk PNGARG((png_structp png_ptr, PNG_EXTERN void png_write_chunk PNGARG((png_structp png_ptr,
@ -1466,7 +1514,8 @@ PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));
/* write various chunks */ /* write various chunks */
/* Write the IHDR chunk, and update the png_struct with the necessary /* Write the IHDR chunk, and update the png_struct with the necessary
information. */ * information.
*/
PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
png_uint_32 height, png_uint_32 height,
int bit_depth, int color_type, int compression_type, int filter_type, int bit_depth, int color_type, int compression_type, int filter_type,
@ -1496,6 +1545,11 @@ PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
double blue_x, double blue_y)); double blue_x, double blue_y));
#endif #endif
#if defined(PNG_WRITE_sRGB_SUPPORTED)
PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
png_byte srgb_intent));
#endif
#if defined(PNG_WRITE_tRNS_SUPPORTED) #if defined(PNG_WRITE_tRNS_SUPPORTED)
PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,
png_color_16p values, int number, int color_type)); png_color_16p values, int number, int color_type));
@ -1513,7 +1567,7 @@ PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
#if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) #if defined(PNG_WRITE_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
png_charp key, png_bytepp new_key)); png_charp key, png_charpp new_key));
#endif #endif
#if defined(PNG_WRITE_tEXt_SUPPORTED) #if defined(PNG_WRITE_tEXt_SUPPORTED)
@ -1698,7 +1752,8 @@ PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
#endif #endif
/* The following decodes the appropriate chunks, and does error correction, /* The following decodes the appropriate chunks, and does error correction,
* then calls the appropriate callback for the chunk if it is valid */ * then calls the appropriate callback for the chunk if it is valid.
*/
/* decode the IHDR chunk */ /* decode the IHDR chunk */
PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
@ -1723,6 +1778,11 @@ PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
png_uint_32 length)); png_uint_32 length));
#endif #endif
#if defined(PNG_READ_sRGB_SUPPORTED)
PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
png_uint_32 length));
#endif
#if defined(PNG_READ_tRNS_SUPPORTED) #if defined(PNG_READ_tRNS_SUPPORTED)
PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
png_uint_32 length)); png_uint_32 length));

225
pngconf.h
View File

@ -1,66 +1,69 @@
/* pngconf.c - machine configurable file for libpng /* pngconf.c - machine configurable file for libpng
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
/* Any machine specific code is near the front of this file, so if you /* Any machine specific code is near the front of this file, so if you
are configuring libpng for a machine, you may want to read the section * are configuring libpng for a machine, you may want to read the section
starting here down to where it starts to typedef png_color, png_text, * starting here down to where it starts to typedef png_color, png_text,
and png_info */ * and png_info.
*/
#ifndef PNGCONF_H #ifndef PNGCONF_H
#define PNGCONF_H #define PNGCONF_H
/* This is the size of the compression buffer, and thus the size of /* This is the size of the compression buffer, and thus the size of
an IDAT chunk. Make this whatever size you feel is best for your * an IDAT chunk. Make this whatever size you feel is best for your
machine. One of these will be allocated per png_struct. When this * machine. One of these will be allocated per png_struct. When this
is full, it writes the data to the disk, and does some other * is full, it writes the data to the disk, and does some other
calculations. Making this an extreamly small size will slow * calculations. Making this an extreamly small size will slow
the library down, but you may want to experiment to determine * the library down, but you may want to experiment to determine
where it becomes significant, if you are concerned with memory * where it becomes significant, if you are concerned with memory
usage. Note that zlib allocates at least 32Kb also. For readers, * usage. Note that zlib allocates at least 32Kb also. For readers,
this describes the size of the buffer available to read the data in. * this describes the size of the buffer available to read the data in.
Unless this gets smaller then the size of a row (compressed), * Unless this gets smaller then the size of a row (compressed),
it should not make much difference how big this is. */ * it should not make much difference how big this is.
*/
#define PNG_ZBUF_SIZE 8192 #define PNG_ZBUF_SIZE 8192
/* If you are running on a machine where you cannot allocate more /* If you are running on a machine where you cannot allocate more
than 64K of memory at once, uncomment this. While libpng will not * than 64K of memory at once, uncomment this. While libpng will not
normally need that much memory in a chunk (unless you load up a very * normally need that much memory in a chunk (unless you load up a very
large file), zlib needs to know how big of a chunk it can use, and * large file), zlib needs to know how big of a chunk it can use, and
libpng thus makes sure to check any memory allocation to verify it * libpng thus makes sure to check any memory allocation to verify it
will fit into memory. * will fit into memory.
#define PNG_MAX_MALLOC_64K #define PNG_MAX_MALLOC_64K
*/ */
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
#define PNG_MAX_MALLOC_64K #define PNG_MAX_MALLOC_64K
#endif #endif
/* This protects us against compilers which run on a windowing system /* This protects us against compilers which run on a windowing system
and thus don't have or would rather us not use the stdio types: * and thus don't have or would rather us not use the stdio types:
stdin, stdout, and stderr. The only one currently used is stderr * stdin, stdout, and stderr. The only one currently used is stderr
in png_error() and png_warning(). #defining PNG_NO_STDIO will * in png_error() and png_warning(). #defining PNG_NO_STDIO will
prevent these from being compiled and used. */ * prevent these from being compiled and used.
* #define PNG_NO_STDIO
*/
/* #define PNG_NO_STDIO */ /* We still need stdio.h for FILE even when PNG_NO_STDIO is defined.
*/
/* for FILE. If you are not using standard io, you don't need this */
#ifndef PNG_NO_STDIO
#include <stdio.h> #include <stdio.h>
#endif
/* This macro protects us against machines that don't have function /* This macro protects us against machines that don't have function
prototypes (ie K&R style headers). If your compiler does not handle * prototypes (ie K&R style headers). If your compiler does not handle
function prototypes, define this macro and use the included ansi2knr. * function prototypes, define this macro and use the included ansi2knr.
I've always been able to use _NO_PROTO as the indicator, but you may * I've always been able to use _NO_PROTO as the indicator, but you may
need to drag the empty declaration out in front of here, or change the * need to drag the empty declaration out in front of here, or change the
ifdef to suit your own needs. */ * ifdef to suit your own needs.
*/
#ifndef PNGARG #ifndef PNGARG
#ifdef OF /* zlib prototype munger */ #ifdef OF /* zlib prototype munger */
@ -77,8 +80,12 @@
#endif /* PNGARG */ #endif /* PNGARG */
/* Try to determine if we are compiling on a Mac */ /* Try to determine if we are compiling on a Mac. Note that testing for
#if defined(__MWERKS__) ||defined(applec) ||defined(THINK_C) ||defined(__SC__) * just __MWERKS__ is not good enough, because the Codewarrior is now used
* on non-Mac platforms.
*/
#if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
defined(THINK_C) || defined(__SC__)
#define MACOS #define MACOS
#endif #endif
@ -88,27 +95,28 @@
#endif #endif
/* This is an attempt to force a single setjmp behaviour on Linux. If /* This is an attempt to force a single setjmp behaviour on Linux. If
the X config stuff didn't define _BSD_SOURCE we wouldn't need this. */ * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
#ifdef linux */
#ifdef __linux__
#ifdef _BSD_SOURCE #ifdef _BSD_SOURCE
#define _PNG_SAVE_BSD_SOURCE #define _PNG_SAVE_BSD_SOURCE
#undef _BSD_SOURCE #undef _BSD_SOURCE
#endif #endif
#ifdef _SETJMP_H #ifdef _SETJMP_H
#error __png_h_already_includes_setjmp_h__ __png.h__ already includes setjmp.h
#error __dont_include_it_again__ __dont__ include it again
#endif #endif
#endif /* linux */ #endif /* __linux__ */
/* include setjmp.h for error handling */ /* include setjmp.h for error handling */
#include <setjmp.h> #include <setjmp.h>
#ifdef linux #ifdef __linux__
#ifdef _PNG_SAVE_BSD_SOURCE #ifdef _PNG_SAVE_BSD_SOURCE
#define _BSD_SOURCE #define _BSD_SOURCE
#undef _PNG_SAVE_BSD_SOURCE #undef _PNG_SAVE_BSD_SOURCE
#endif #endif
#endif /* linux */ #endif /* __linux__ */
#ifdef BSD #ifdef BSD
#include <strings.h> #include <strings.h>
@ -119,9 +127,6 @@
/* Other defines for things like memory and the like can go here. */ /* Other defines for things like memory and the like can go here. */
#ifdef PNG_INTERNAL #ifdef PNG_INTERNAL
#include <stdlib.h> #include <stdlib.h>
/* Where do we need this???
#include <ctype.h>
*/
/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which /* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which
* aren't usually used outside the library (as far as I know), so it is * aren't usually used outside the library (as far as I know), so it is
@ -133,12 +138,14 @@
#define PNG_EXTERN #define PNG_EXTERN
/* Other defines specific to compilers can go here. Try to keep /* Other defines specific to compilers can go here. Try to keep
them inside an appropriate ifdef/endif pair for portability */ * them inside an appropriate ifdef/endif pair for portability.
*/
#if defined(MACOS) #if defined(MACOS)
/* We need to check that <math.h> hasn't already been included earlier /* We need to check that <math.h> hasn't already been included earlier
as it seems it doesn't agree with <fp.h>, yet we should really use * as it seems it doesn't agree with <fp.h>, yet we should really use
<fp.h> if possible. */ * <fp.h> if possible.
*/
#if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) #if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
#include <fp.h> #include <fp.h>
#endif #endif
@ -147,8 +154,9 @@
#endif #endif
/* For some reason, Borland C++ defines memcmp, etc. in mem.h, not /* For some reason, Borland C++ defines memcmp, etc. in mem.h, not
stdlib.h like it should (I think). Or perhaps this is a C++ * stdlib.h like it should (I think). Or perhaps this is a C++
"feature"? */ * "feature"?
*/
#ifdef __TURBOC__ #ifdef __TURBOC__
#include <mem.h> #include <mem.h>
#include "alloc.h" #include "alloc.h"
@ -159,34 +167,36 @@
#endif #endif
/* This controls how fine the dithering gets. As this allocates /* This controls how fine the dithering gets. As this allocates
a largish chunk of memory (32K), those who are not as concerned * a largish chunk of memory (32K), those who are not as concerned
with dithering quality can decrease some or all of these. */ * with dithering quality can decrease some or all of these.
*/
#define PNG_DITHER_RED_BITS 5 #define PNG_DITHER_RED_BITS 5
#define PNG_DITHER_GREEN_BITS 5 #define PNG_DITHER_GREEN_BITS 5
#define PNG_DITHER_BLUE_BITS 5 #define PNG_DITHER_BLUE_BITS 5
/* This controls how fine the gamma correction becomes when you /* This controls how fine the gamma correction becomes when you
are only interested in 8 bits anyway. Increasing this value * are only interested in 8 bits anyway. Increasing this value
results in more memory being used, and more pow() functions * results in more memory being used, and more pow() functions
being called to fill in the gamma tables. Don't set this * being called to fill in the gamma tables. Don't set this value
value less then 8, and even that may not work (I haven't tested * less then 8, and even that may not work (I haven't tested it).
it). */ */
#define PNG_MAX_GAMMA_8 11 #define PNG_MAX_GAMMA_8 11
/* This controls how much a difference in gamma we can tolerate before /* This controls how much a difference in gamma we can tolerate before
we actually start doing gamma conversion. */ * we actually start doing gamma conversion.
*/
#define PNG_GAMMA_THRESHOLD 0.05 #define PNG_GAMMA_THRESHOLD 0.05
#endif /* PNG_INTERNAL */ #endif /* PNG_INTERNAL */
/* The following uses const char * instead of char * for error /* The following uses const char * instead of char * for error
and warning message functions, so some compilers won't complain. * and warning message functions, so some compilers won't complain.
If you want to use const, define PNG_USE_CONST here. It is not * If you want to use const, define PNG_USE_CONST here. It is not
normally defined to make configuration easier, as it is not a * normally defined to make configuration easier, as it is not a
critical part of the code. * critical part of the code.
*/ */
#undef PNG_USE_CONST #define PNG_USE_CONST
#ifdef PNG_USE_CONST #ifdef PNG_USE_CONST
# define PNG_CONST const # define PNG_CONST const
@ -195,19 +205,34 @@
#endif #endif
/* The following defines give you the ability to remove code from the /* The following defines give you the ability to remove code from the
library that you will not be using. I wish I could figure out how to * library that you will not be using. I wish I could figure out how to
automate this, but I can't do that without making it seriously hard * automate this, but I can't do that without making it seriously hard
on the users. So if you are not using an ability, change the #define * on the users. So if you are not using an ability, change the #define
to and #undef, and that part of the library will not be compiled. If * to and #undef, and that part of the library will not be compiled. If
your linker can't find a function, you may want to make sure the * your linker can't find a function, you may want to make sure the
ability is defined here. Some of these depend upon some others being * ability is defined here. Some of these depend upon some others being
defined. I haven't figured out all the interactions here, so you may * defined. I haven't figured out all the interactions here, so you may
have to experiment awhile to get everything to compile. If you are * have to experiment awhile to get everything to compile. If you are
creating or using a shared library, you probably shouldn't touch this, * creating or using a shared library, you probably shouldn't touch this,
as it will affect the size of the structures, and this will cause bad * as it will affect the size of the structures, and this will cause bad
things to happen if the library and/or application ever change. */ * things to happen if the library and/or application ever change.
*/
/* Any transformations you will not be using can be undef'ed here */ /* Any transformations you will not be using can be undef'ed here */
/* GR-P, 0.96a: Set "*FULLY_SUPPORTED as default but allow user
to turn it off with "*NOT_FULLY_SUPPORTED" on the compile line,
then pick and choose which ones to define without having to edit
this file */
#ifndef PNG_READ_NOT_FULLY_SUPPORTED
#define PNG_READ_FULLY_SUPPORTED
#endif
#ifndef PNG_WRITE_NOT_FULLY_SUPPORTED
#define PNG_WRITE_FULLY_SUPPORTED
#endif
#ifdef PNG_READ_FULLY_SUPPORTED
#define PNG_PROGRESSIVE_READ_SUPPORTED #define PNG_PROGRESSIVE_READ_SUPPORTED
#define PNG_READ_OPT_PLTE_SUPPORTED #define PNG_READ_OPT_PLTE_SUPPORTED
#define PNG_READ_INTERLACING_SUPPORTED #define PNG_READ_INTERLACING_SUPPORTED
@ -226,7 +251,9 @@
#define PNG_READ_GRAY_TO_RGB_SUPPORTED #define PNG_READ_GRAY_TO_RGB_SUPPORTED
#define PNG_READ_SWAP_ALPHA_SUPPORTED #define PNG_READ_SWAP_ALPHA_SUPPORTED
#define PNG_READ_STRIP_ALPHA_SUPPORTED #define PNG_READ_STRIP_ALPHA_SUPPORTED
#endif /* PNG_READ_FULLY_SUPPORTED */
#ifdef PNG_WRITE_FULLY_SUPPORTED
#define PNG_WRITE_INTERLACING_SUPPORTED #define PNG_WRITE_INTERLACING_SUPPORTED
#define PNG_WRITE_SHIFT_SUPPORTED #define PNG_WRITE_SHIFT_SUPPORTED
#define PNG_WRITE_PACK_SUPPORTED #define PNG_WRITE_PACK_SUPPORTED
@ -238,6 +265,9 @@
#define PNG_WRITE_FLUSH_SUPPORTED #define PNG_WRITE_FLUSH_SUPPORTED
#define PNG_WRITE_SWAP_ALPHA_SUPPORTED #define PNG_WRITE_SWAP_ALPHA_SUPPORTED
#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED #define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
#endif /*PNG_WRITE_FULLY_SUPPORTED */
#define PNG_TIME_RFC1152_SUPPORTED
/* These are currently experimental features */ /* These are currently experimental features */
#undef PNG_READ_16_TO_8_ACCURATE_SHIFT_SUPPORTED /* very little testing */ #undef PNG_READ_16_TO_8_ACCURATE_SHIFT_SUPPORTED /* very little testing */
@ -247,7 +277,6 @@
#undef PNG_READ_BIG_ENDIAN_SUPPORTED /* some testing */ #undef PNG_READ_BIG_ENDIAN_SUPPORTED /* some testing */
/* These functions are turned off by default, as they will be phased out. */ /* These functions are turned off by default, as they will be phased out. */
#undef PNG_USE_OWN_CRC
#undef PNG_USELESS_TESTS_SUPPORTED #undef PNG_USELESS_TESTS_SUPPORTED
#undef PNG_CORRECT_PALETTE_SUPPORTED #undef PNG_CORRECT_PALETTE_SUPPORTED
@ -258,6 +287,7 @@
* and RGBA images. * and RGBA images.
*/ */
#ifdef PNG_READ_FULLY_SUPPORTED
#define PNG_READ_bKGD_SUPPORTED #define PNG_READ_bKGD_SUPPORTED
#define PNG_READ_cHRM_SUPPORTED #define PNG_READ_cHRM_SUPPORTED
#define PNG_READ_gAMA_SUPPORTED #define PNG_READ_gAMA_SUPPORTED
@ -266,11 +296,14 @@
#define PNG_READ_pCAL_SUPPORTED #define PNG_READ_pCAL_SUPPORTED
#define PNG_READ_pHYs_SUPPORTED #define PNG_READ_pHYs_SUPPORTED
#define PNG_READ_sBIT_SUPPORTED #define PNG_READ_sBIT_SUPPORTED
#define PNG_READ_sRGB_SUPPORTED
#define PNG_READ_tEXt_SUPPORTED #define PNG_READ_tEXt_SUPPORTED
#define PNG_READ_tIME_SUPPORTED #define PNG_READ_tIME_SUPPORTED
#define PNG_READ_tRNS_SUPPORTED #define PNG_READ_tRNS_SUPPORTED
#define PNG_READ_zTXt_SUPPORTED #define PNG_READ_zTXt_SUPPORTED
#endif /* PNG_READ_FULLY_SUPPORTED */
#ifdef PNG_WRITE_FULLY_SUPPORTED
#define PNG_WRITE_bKGD_SUPPORTED #define PNG_WRITE_bKGD_SUPPORTED
#define PNG_WRITE_cHRM_SUPPORTED #define PNG_WRITE_cHRM_SUPPORTED
#define PNG_WRITE_gAMA_SUPPORTED #define PNG_WRITE_gAMA_SUPPORTED
@ -279,10 +312,12 @@
#define PNG_WRITE_pCAL_SUPPORTED #define PNG_WRITE_pCAL_SUPPORTED
#define PNG_WRITE_pHYs_SUPPORTED #define PNG_WRITE_pHYs_SUPPORTED
#define PNG_WRITE_sBIT_SUPPORTED #define PNG_WRITE_sBIT_SUPPORTED
#define PNG_WRITE_sRGB_SUPPORTED
#define PNG_WRITE_tEXt_SUPPORTED #define PNG_WRITE_tEXt_SUPPORTED
#define PNG_WRITE_tIME_SUPPORTED #define PNG_WRITE_tIME_SUPPORTED
#define PNG_WRITE_tRNS_SUPPORTED #define PNG_WRITE_tRNS_SUPPORTED
#define PNG_WRITE_zTXt_SUPPORTED #define PNG_WRITE_zTXt_SUPPORTED
#endif /* PNG_WRITE_FULLY_SUPPORTED */
/* need the time information for reading tIME chunks */ /* need the time information for reading tIME chunks */
#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED)
@ -336,18 +371,19 @@ typedef size_t png_size_t;
#endif /* LDATA != 1 */ #endif /* LDATA != 1 */
/* Possibly useful for moving data out of default segment. /* Possibly useful for moving data out of default segment.
Uncomment it if you want. Could also define FARDATA as * Uncomment it if you want. Could also define FARDATA as
const if your compiler supports it. (SJT) * const if your compiler supports it. (SJT)
# define FARDATA FAR # define FARDATA FAR
*/ */
#endif /* __WIN32__, __FLAT__ */ #endif /* __WIN32__, __FLAT__ */
#endif /* __BORLANDC__ */ #endif /* __BORLANDC__ */
/* Suggest testing for specific compiler first before testing for /* Suggest testing for specific compiler first before testing for
FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM,
making reliance oncertain keywords suspect. (SJT) */ * making reliance oncertain keywords suspect. (SJT)
*/
/* MSC Medium model */ /* MSC Medium model */
#if defined(FAR) #if defined(FAR)
@ -400,18 +436,29 @@ typedef charf * png_zcharp;
typedef charf * FAR * png_zcharpp; typedef charf * FAR * png_zcharpp;
typedef z_stream FAR * png_zstreamp; typedef z_stream FAR * png_zstreamp;
/* allow for compilation as dll under windows */ /* allow for compilation as dll under MS Windows */
#ifdef __WIN32DLL__ #ifdef __WIN32DLL__
#define PNG_EXPORT(type,symbol) __declspec(dllexport) type symbol #define PNG_EXPORT(type,symbol) __declspec(dllexport) type symbol
#endif #endif
/* allow for compilation as dll with BORLAND C++ 5.0 */
#if defined(__BORLANDC__) && defined(_Windows) && defined(__DLL__)
# define PNG_EXPORT(t,s) t _export s
#endif
/* allow for compilation as shared lib under BeOS */
#ifdef __BEOSDLL__
#define PNG_EXPORT(type,symbol) __declspec(export) type symbol
#endif
#ifndef PNG_EXPORT #ifndef PNG_EXPORT
#define PNG_EXPORT(t,s) t s #define PNG_EXPORT(t,s) t s
#endif #endif
/* User may want to use these so not in PNG_INTERNAL. Any library functions /* User may want to use these so not in PNG_INTERNAL. Any library functions
that are passed far data must be model independent. */ * that are passed far data must be model independent.
*/
#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ #if defined(USE_FAR_KEYWORD) /* memory model independent fns */
/* use this to make far-to-near assignments */ /* use this to make far-to-near assignments */

63
pngerror.c
View File

@ -1,16 +1,17 @@
/* pngerror.c - stub functions for i/o and memory allocation /* pngerror.c - stub functions for i/o and memory allocation
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*
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 * need special error handling are expected to write replacement functions
and use png_set_error_fn() to use those functions. See the instructions * and use png_set_error_fn() to use those functions. See the instructions
at each function. */ * at each function.
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
@ -21,9 +22,10 @@ static void png_default_warning PNGARG((png_structp png_ptr,
png_const_charp message)); png_const_charp message));
/* This function is called whenever there is a fatal error. This function /* This function is called whenever there is a fatal error. This function
should not be changed. If there is a need to handle errors differently, * should not be changed. If there is a need to handle errors differently,
you should supply a replacement error function and use png_set_error_fn() * you should supply a replacement error function and use png_set_error_fn()
to replace the error function at run-time. */ * to replace the error function at run-time.
*/
void void
png_error(png_structp png_ptr, png_const_charp message) png_error(png_structp png_ptr, png_const_charp message)
{ {
@ -36,9 +38,10 @@ png_error(png_structp png_ptr, png_const_charp message)
} }
/* This function is called whenever there is a non-fatal error. This function /* This function is called whenever there is a non-fatal error. This function
should not be changed. If there is a need to handle warnings differently, * should not be changed. If there is a need to handle warnings differently,
you should supply a replacement warning function and use * you should supply a replacement warning function and use
png_set_error_fn() to replace the warning function at run-time. */ * png_set_error_fn() to replace the warning function at run-time.
*/
void void
png_warning(png_structp png_ptr, png_const_charp message) png_warning(png_structp png_ptr, png_const_charp message)
{ {
@ -49,9 +52,10 @@ png_warning(png_structp png_ptr, png_const_charp message)
} }
/* This is the default error handling function. Note that replacements for /* This is the default error handling function. Note that replacements for
this function MUST NOT RETURN, or the program will likely crash. This * this function MUST NOT RETURN, or the program will likely crash. This
function is used by default, or if the program supplies NULL for the * function is used by default, or if the program supplies NULL for the
error function pointer in png_set_error_fn(). */ * error function pointer in png_set_error_fn().
*/
static void static void
png_default_error(png_structp png_ptr, png_const_charp message) png_default_error(png_structp png_ptr, png_const_charp message)
{ {
@ -71,9 +75,10 @@ png_default_error(png_structp png_ptr, png_const_charp message)
} }
/* This function is called when there is a warning, but the library thinks /* This function is called when there is a warning, but the library thinks
it can continue anyway. Replacement functions don't have to do anything * it can continue anyway. Replacement functions don't have to do anything
here if you don't want to. In the default configuration, png_ptr is * here if you don't want to. In the default configuration, png_ptr is
not used, but it is passed in case it may be useful. */ * not used, but it is passed in case it may be useful.
*/
static void static void
png_default_warning(png_structp png_ptr, png_const_charp message) png_default_warning(png_structp png_ptr, png_const_charp message)
{ {
@ -86,9 +91,10 @@ png_default_warning(png_structp png_ptr, png_const_charp message)
} }
/* This function is called when the application wants to use another method /* This function is called when the application wants to use another method
of handling errors and warnings. Note that the error function MUST NOT * of handling errors and warnings. Note that the error function MUST NOT
return to the calling routine or serious problems will occur. The return * return to the calling routine or serious problems will occur. The return
method used in the default routine calls longjmp(png_ptr->jmpbuf, 1) */ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
*/
void void
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warning_fn) png_error_ptr error_fn, png_error_ptr warning_fn)
@ -100,8 +106,9 @@ png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
/* This function returns a pointer to the error_ptr associated with the user /* This function returns a pointer to the error_ptr associated with the user
functions. The application should free any memory associated with this * functions. The application should free any memory associated with this
pointer before png_write_destroy and png_read_destroy are called. */ * pointer before png_write_destroy and png_read_destroy are called.
*/
png_voidp png_voidp
png_get_error_ptr(png_structp png_ptr) png_get_error_ptr(png_structp png_ptr)
{ {

52
pngget.c
View File

@ -1,12 +1,12 @@
/* pngget.c - retrieval of values from info struct /* pngget.c - retrieval of values from info struct
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
@ -109,6 +109,21 @@ png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
} }
#endif #endif
#if defined(PNG_READ_sRGB_SUPPORTED)
png_uint_32
png_get_sRGB(png_structp png_ptr, png_infop info_ptr, png_byte *file_srgb_intent)
{
if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sRGB &&
*file_srgb_intent != NULL)
{
png_debug1(1, "in %s retrieval function\n", "sRGB");
*file_srgb_intent = (png_byte)info_ptr->srgb_intent;
return (PNG_INFO_sRGB);
}
return (0);
}
#endif
#if defined(PNG_READ_hIST_SUPPORTED) #if defined(PNG_READ_hIST_SUPPORTED)
png_uint_32 png_uint_32
png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist) png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
@ -196,14 +211,23 @@ png_uint_32
png_get_pHYs(png_structp png_ptr, png_infop info_ptr, png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
{ {
if (info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs && png_uint_32 retval = 0;
res_x != NULL && res_y != NULL && unit_type != NULL)
if (info_ptr != NULL && info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function\n", "pHYs"); png_debug1(1, "in %s retrieval function\n", "pHYs");
*res_x = info_ptr->x_pixels_per_unit; if (res_x != NULL && res_y != NULL)
*res_y = info_ptr->y_pixels_per_unit; {
*unit_type = (int)info_ptr->phys_unit_type; *res_x = info_ptr->x_pixels_per_unit;
return (PNG_INFO_pHYs); *res_y = info_ptr->y_pixels_per_unit;
retval |= PNG_INFO_pHYs;
}
if (unit_type != NULL)
{
*unit_type = (int)info_ptr->phys_unit_type;
retval |= PNG_INFO_pHYs;
}
return (retval);
} }
return (0); return (0);
} }
@ -251,7 +275,7 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
*text_ptr = info_ptr->text; *text_ptr = info_ptr->text;
if (num_text != NULL) if (num_text != NULL)
*num_text = info_ptr->num_text; *num_text = info_ptr->num_text;
return (info_ptr->num_text); return ((png_uint_32)info_ptr->num_text);
} }
return(0); return(0);
} }

25
pngmem.c
View File

@ -1,15 +1,16 @@
/* pngmem.c - stub functions for memory allocation /* pngmem.c - stub functions for memory allocation
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*
This file provides a location for all memory allocation. Users which * This file provides a location for all memory allocation. Users which
need special memory handling are expected to modify the code in this file * need special memory handling are expected to modify the code in this file
to meet their needs. See the instructions at each function. */ * to meet their needs. See the instructions at each function.
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
@ -81,7 +82,7 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
png_error(png_ptr, "Cannot Allocate > 64K"); png_error(png_ptr, "Cannot Allocate > 64K");
#endif #endif
if (size == (png_uint_32)(65536L)) if (size == (png_uint_32)65536L)
{ {
if (png_ptr->offset_table == NULL) if (png_ptr->offset_table == NULL)
{ {
@ -139,7 +140,7 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
for (i = 0; i < num_blocks; i++) for (i = 0; i < num_blocks; i++)
{ {
png_ptr->offset_table_ptr[i] = (png_bytep)hptr; png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
hptr += 65536L; hptr += (png_uint_32)65536L;
} }
png_ptr->offset_table_number = num_blocks; png_ptr->offset_table_number = num_blocks;

59
pngpread.c
View File

@ -1,12 +1,12 @@
/* pngpread.c - read a png file in push mode /* pngpread.c - read a png file in push mode
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
@ -116,10 +116,11 @@ void
png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
{ {
/* First we make sure we have enough data for the 4 byte chunk name /* First we make sure we have enough data for the 4 byte chunk name
and the 4 byte chunk length before proceeding with decoding the * and the 4 byte chunk length before proceeding with decoding the
chunk data. To fully decode each of these chunks, we also make * chunk data. To fully decode each of these chunks, we also make
sure we have enough data in the buffer for the 4 byte CRC at the * sure we have enough data in the buffer for the 4 byte CRC at the
end of every chunk (except IDAT, which is handled separately). */ * end of every chunk (except IDAT, which is handled separately).
*/
if (!(png_ptr->flags & PNG_FLAG_HAVE_CHUNK_HEADER)) if (!(png_ptr->flags & PNG_FLAG_HAVE_CHUNK_HEADER))
{ {
png_byte chunk_length[4]; png_byte chunk_length[4];
@ -160,8 +161,9 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
{ {
/* If we reach an IDAT chunk, this means we have read all of the /* If we reach an IDAT chunk, this means we have read all of the
header chunks, and we can start reading the image (or if this * header chunks, and we can start reading the image (or if this
is called after the image has been read - we have an error). */ * is called after the image has been read - we have an error).
*/
if (png_ptr->mode & PNG_HAVE_IDAT) if (png_ptr->mode & PNG_HAVE_IDAT)
{ {
if (png_ptr->push_length == 0) if (png_ptr->push_length == 0)
@ -227,6 +229,18 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length); png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sRGB_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
{
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
{
png_push_save_buffer(png_ptr);
return;
}
png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
}
#endif
#if defined(PNG_READ_tRNS_SUPPORTED) #if defined(PNG_READ_tRNS_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
{ {
@ -783,11 +797,11 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
png_ptr->skip_length = 0; /* This may not be necessary */ png_ptr->skip_length = 0; /* This may not be necessary */
if (length > 65535L) /* We can't hold the entire string in memory */ if (length > (png_uint_32)65535L) /* Can't hold the entire string in memory */
{ {
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); png_warning(png_ptr, "tEXt chunk too large to fit in memory");
png_ptr->skip_length = length - 65535L; png_ptr->skip_length = length - (png_uint_32)65535L;
length = 65535L; length = (png_uint_32)65535L;
} }
#endif #endif
@ -866,7 +880,7 @@ png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
* to be able to store the uncompressed data. Actually, the threshold * to be able to store the uncompressed data. Actually, the threshold
* is probably around 32K, but it isn't as definite as 64K is. * is probably around 32K, but it isn't as definite as 64K is.
*/ */
if (length > 65535L) if (length > (png_uint_32)65535L)
{ {
png_warning(png_ptr, "zTXt chunk too large to fit in memory"); png_warning(png_ptr, "zTXt chunk too large to fit in memory");
png_push_crc_skip(png_ptr, length); png_push_crc_skip(png_ptr, length);
@ -1029,11 +1043,12 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
#endif #endif
/* This function is called when we haven't found a handler for this /* This function is called when we haven't found a handler for this
chunk. In the future we will have code here which can handle * chunk. In the future we will have code here which can handle
user-defined callback functions for unknown chunks before they are * user-defined callback functions for unknown chunks before they are
ignored or cause an error. If there isn't a problem with the * ignored or cause an error. If there isn't a problem with the
chunk itself (ie a bad chunk name or a critical chunk), the chunk * chunk itself (ie a bad chunk name or a critical chunk), the chunk
is (currently) silently ignored. */ * is (currently) silently ignored.
*/
void void
png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {

100
pngread.c
View File

@ -1,19 +1,22 @@
/* pngread.c - read a PNG file /* pngread.c - read a PNG file
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ *
* This file contains routines that an application calls directly to
* read a PNG file or stream.
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
/* Create a PNG structure for reading, and allocate any memory needed. */ /* Create a PNG structure for reading, and allocate any memory needed. */
png_structp png_structp
png_create_read_struct(png_charp user_png_ver, png_voidp error_ptr, png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn) png_error_ptr error_fn, png_error_ptr warn_fn)
{ {
png_structp png_ptr; png_structp png_ptr;
@ -76,7 +79,6 @@ png_create_read_struct(png_charp user_png_ver, png_voidp error_ptr,
return (png_ptr); return (png_ptr);
} }
/* Initialize PNG structure for reading, and allocate any memory needed. /* Initialize PNG structure for reading, and allocate any memory needed.
This interface is depreciated in favour of the png_create_read_struct(), This interface is depreciated in favour of the png_create_read_struct(),
and it will eventually disappear. */ and it will eventually disappear. */
@ -215,6 +217,10 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
png_handle_sBIT(png_ptr, info_ptr, length); png_handle_sBIT(png_ptr, info_ptr, length);
#endif #endif
#if defined(PNG_READ_sRGB_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
png_handle_sRGB(png_ptr, info_ptr, length);
#endif
#if defined(PNG_READ_tEXt_SUPPORTED) #if defined(PNG_READ_tEXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
png_handle_tEXt(png_ptr, info_ptr, length); png_handle_tEXt(png_ptr, info_ptr, length);
@ -247,10 +253,11 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
png_read_transform_info(png_ptr, info_ptr); png_read_transform_info(png_ptr, info_ptr);
} }
/* initialize palette, background, etc, after transformations /* Initialize palette, background, etc, after transformations
are set, but before any reading takes place. This allows * are set, but before any reading takes place. This allows
the user to obtail a gamma corrected palette, for example. * the user to obtail a gamma corrected palette, for example.
If the user doesn't call this, we will do it ourselves. */ * If the user doesn't call this, we will do it ourselves.
*/
void void
png_start_read_image(png_structp png_ptr) png_start_read_image(png_structp png_ptr)
{ {
@ -439,23 +446,26 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
} }
/* Read one or more rows of image data. If the image is interlaced, /* Read one or more rows of image data. If the image is interlaced,
and png_set_interlace_handling() has been called, the rows need to * and png_set_interlace_handling() has been called, the rows need to
to contain the contents of the rows from the previous pass. If * contain the contents of the rows from the previous pass. If the
the image has alpha or transparency, and png_handle_alpha() has been * image has alpha or transparency, and png_handle_alpha() has been
called, the rows contents must be initialized to the contents of the * called, the rows contents must be initialized to the contents of the
screen. "row" holds the actual image, and pixels are placed in it * screen.
as they arrive. If the image is displayed after each pass, it will *
appear to "sparkle" in. "display_row" can be used to display a * "row" holds the actual image, and pixels are placed in it
"chunky" progressive image, with finer detail added as it becomes * as they arrive. If the image is displayed after each pass, it will
available. If you do not want this "chunky" display, you may pass * appear to "sparkle" in. "display_row" can be used to display a
NULL for display_row. If you do not want the sparkle display, and * "chunky" progressive image, with finer detail added as it becomes
you have not called png_handle_alpha(), you may pass NULL for rows. * available. If you do not want this "chunky" display, you may pass
If you have called png_handle_alpha(), and the image has either an * NULL for display_row. If you do not want the sparkle display, and
alpha channel or a transparency chunk, you must provide a buffer for * you have not called png_handle_alpha(), you may pass NULL for rows.
rows. In this case, you do not have to provide a display_row buffer * If you have called png_handle_alpha(), and the image has either an
also, but you may. If the image is not interlaced, or if you have * alpha channel or a transparency chunk, you must provide a buffer for
not called png_set_interlace_handling(), the display_row buffer will * rows. In this case, you do not have to provide a display_row buffer
be ignored, so pass NULL to it. */ * also, but you may. If the image is not interlaced, or if you have
* not called png_set_interlace_handling(), the display_row buffer will
* be ignored, so pass NULL to it.
*/
void void
png_read_rows(png_structp png_ptr, png_bytepp row, png_read_rows(png_structp png_ptr, png_bytepp row,
@ -491,14 +501,15 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
} }
/* Read the entire image. If the image has an alpha channel or a tRNS /* Read the entire image. If the image has an alpha channel or a tRNS
chunk, and you have called png_handle_alpha(), you will need to * chunk, and you have called png_handle_alpha(), you will need to
initialize the image to the current image that PNG will be overlaying. * initialize the image to the current image that PNG will be overlaying.
We set the num_rows again here, in case it was incorrectly set in * We set the num_rows again here, in case it was incorrectly set in
png_read_start_row() by a call to png_read_update_info() or * png_read_start_row() by a call to png_read_update_info() or
png_start_read_image() if png_set_interlace_handling() wasn't called * png_start_read_image() if png_set_interlace_handling() wasn't called
prior to either of these functions like it should have been. You can * prior to either of these functions like it should have been. You can
only call this function once. If you desire to have an image for * only call this function once. If you desire to have an image for
each pass of a interlaced image, use png_read_rows() instead */ * each pass of a interlaced image, use png_read_rows() instead.
*/
void void
png_read_image(png_structp png_ptr, png_bytepp image) png_read_image(png_structp png_ptr, png_bytepp image)
{ {
@ -524,8 +535,9 @@ png_read_image(png_structp png_ptr, png_bytepp image)
} }
/* Read the end of the PNG file. Will not read past the end of the /* Read the end of the PNG file. Will not read past the end of the
file, will verify the end is accurate, and will read any comments * file, will verify the end is accurate, and will read any comments
or time information at the end of the file, if info is not NULL. */ * or time information at the end of the file, if info is not NULL.
*/
void void
png_read_end(png_structp png_ptr, png_infop info_ptr) png_read_end(png_structp png_ptr, png_infop info_ptr)
{ {
@ -594,6 +606,10 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
png_handle_sBIT(png_ptr, info_ptr, length); png_handle_sBIT(png_ptr, info_ptr, length);
#endif #endif
#if defined(PNG_READ_sRGB_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
png_handle_sRGB(png_ptr, info_ptr, length);
#endif
#if defined(PNG_READ_tEXt_SUPPORTED) #if defined(PNG_READ_tEXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
png_handle_tEXt(png_ptr, info_ptr, length); png_handle_tEXt(png_ptr, info_ptr, length);
@ -659,7 +675,6 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
void void
png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr) png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
{ {
int i;
jmp_buf tmp_jmp; jmp_buf tmp_jmp;
png_error_ptr error_fn; png_error_ptr error_fn;
png_error_ptr warning_fn; png_error_ptr warning_fn;
@ -700,6 +715,7 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
#if defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED)
if (png_ptr->gamma_16_table != NULL) if (png_ptr->gamma_16_table != NULL)
{ {
int i;
for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++) for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
{ {
png_free(png_ptr, png_ptr->gamma_16_table[i]); png_free(png_ptr, png_ptr->gamma_16_table[i]);
@ -710,6 +726,7 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
png_free(png_ptr, png_ptr->gamma_16_table); png_free(png_ptr, png_ptr->gamma_16_table);
if (png_ptr->gamma_16_from_1 != NULL) if (png_ptr->gamma_16_from_1 != NULL)
{ {
int i;
for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++) for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
{ {
png_free(png_ptr, png_ptr->gamma_16_from_1[i]); png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
@ -718,6 +735,7 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
png_free(png_ptr, png_ptr->gamma_16_from_1); png_free(png_ptr, png_ptr->gamma_16_from_1);
if (png_ptr->gamma_16_to_1 != NULL) if (png_ptr->gamma_16_to_1 != NULL)
{ {
int i;
for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++) for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
{ {
png_free(png_ptr, png_ptr->gamma_16_to_1[i]); png_free(png_ptr, png_ptr->gamma_16_to_1[i]);

27
pngrio.c
View File

@ -1,18 +1,19 @@
/* pngrio.c - functions for data input /* pngrio.c - functions for data input
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*
This file provides a location for all input. Users which need * This file provides a location for all input. Users which need
special handling are expected to write a function which has the same * special handling are expected to write a function which has the same
arguments as this, and perform a similar function, but possibly has * arguments as this, and perform a similar function, but possibly has
a different input method. Note that you shouldn't change this * a different input method. Note that you shouldn't change this
function, but rather write a replacement function and then make * function, but rather write a replacement function and then make
libpng use it at run time with png_set_read_fn(...) */ * libpng use it at run time with png_set_read_fn(...).
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"

200
pngrtran.c
View File

@ -1,22 +1,28 @@
/* pngrtran.c - transforms the data in a row for PNG readers /* pngrtran.c - transforms the data in a row for PNG readers
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ *
* This file contains functions optionally called by an application
* in order to tell libpng how to handle data when reading a PNG.
* Transformations which are used in both reading and writing are
* in pngtrans.c.
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
/* With these routines, we avoid an integer divide, which will be slower on /* With these routines, we avoid an integer divide, which will be slower on
many machines. However, it does take more operations than the corresponding * many machines. However, it does take more operations than the corresponding
divide method, so it may be slower on some RISC systems. There are two * divide method, so it may be slower on some RISC systems. There are two
shifts (by 8 or 16 bits) and an addition, versus a single integer divide. * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
The results may also be off by one for certain values. */ * The results may also be off by one for certain values.
*/
/* pixel and background should be in gamma 1.0 space */ /* pixel and background should be in gamma 1.0 space */
#define png_composite(composite, pixel, trans, background) \ #define png_composite(composite, pixel, trans, background) \
@ -42,9 +48,62 @@
#define png_composite_16(composite, pixel, trans, background) \ #define png_composite_16(composite, pixel, trans, background) \
(composite) = (png_uint_16)(((png_uint_32)(pixel) * (png_uint_32)(trans) + \ (composite) = (png_uint_16)(((png_uint_32)(pixel) * (png_uint_32)(trans) + \
(png_uint_32)(background)*(png_uint_32)(65535L - (png_uint_32)(trans)) + \ (png_uint_32)(background)*(png_uint_32)(65535L - (png_uint_32)(trans)) + \
(png_uint_32)32767) / 65535L) (png_uint_32)32767) / (png_uint_32)65535L)
#endif #endif
/* Set the action on getting a CRC error for an ancillary or critical chunk. */
void
png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
{
png_debug(1, "in png_set_crc_action\n");
/* Tell libpng how we react to CRC errors in critical chunks */
switch (crit_action)
{
case PNG_CRC_NO_CHANGE: /* leave setting as is */
break;
case PNG_CRC_WARN_USE: /* warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
break;
case PNG_CRC_QUIET_USE: /* quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
PNG_FLAG_CRC_CRITICAL_IGNORE;
break;
case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */
png_warning(png_ptr, "Can't discard critical data on CRC error.");
case PNG_CRC_ERROR_QUIT: /* error/quit */
case PNG_CRC_DEFAULT:
default:
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
break;
}
switch (ancil_action)
{
case PNG_CRC_NO_CHANGE: /* leave setting as is */
break;
case PNG_CRC_WARN_USE: /* warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
break;
case PNG_CRC_QUIET_USE: /* quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
PNG_FLAG_CRC_ANCILLARY_NOWARN;
break;
case PNG_CRC_ERROR_QUIT: /* error/quit */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
break;
case PNG_CRC_WARN_DISCARD: /* warn/discard data */
case PNG_CRC_DEFAULT:
default:
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
break;
}
}
#if defined(PNG_READ_BACKGROUND_SUPPORTED) #if defined(PNG_READ_BACKGROUND_SUPPORTED)
/* handle alpha and tRNS via a background color */ /* handle alpha and tRNS via a background color */
void void
@ -89,12 +148,13 @@ png_set_strip_alpha(png_structp png_ptr)
#if defined(PNG_READ_DITHER_SUPPORTED) #if defined(PNG_READ_DITHER_SUPPORTED)
/* Dither file to 8 bit. Supply a palette, the current number /* Dither file to 8 bit. Supply a palette, the current number
of elements in the palette, the maximum number of elements * of elements in the palette, the maximum number of elements
allowed, and a histogram if possible. If the current number * allowed, and a histogram if possible. If the current number
of colors is greater then the maximum number, the palette will be * of colors is greater then the maximum number, the palette will be
modified to fit in the maximum number. "full_dither" indicates * modified to fit in the maximum number. "full_dither" indicates
whether we need a dithering cube set up for RGB images, or if we * whether we need a dithering cube set up for RGB images, or if we
simply are reducing the number of colors in a paletted image. */ * simply are reducing the number of colors in a paletted image.
*/
typedef struct png_dsort_struct typedef struct png_dsort_struct
{ {
@ -478,9 +538,10 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
#if defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED)
/* Transform the image from the file_gamma to the screen_gamma. We /* Transform the image from the file_gamma to the screen_gamma. We
only do transformations on images where the file_gamma and screen_gamma * only do transformations on images where the file_gamma and screen_gamma
are not close reciprocals, otherwise it slows things down slightly, and * are not close reciprocals, otherwise it slows things down slightly, and
also needlessly introduces small errors. */ * also needlessly introduces small errors.
*/
void void
png_set_gamma(png_structp png_ptr, double screen_gamma, double file_gamma) png_set_gamma(png_structp png_ptr, double screen_gamma, double file_gamma)
{ {
@ -494,8 +555,9 @@ png_set_gamma(png_structp png_ptr, double screen_gamma, double file_gamma)
#if defined(PNG_READ_EXPAND_SUPPORTED) #if defined(PNG_READ_EXPAND_SUPPORTED)
/* Expand paletted images to rgb, expand grayscale images of /* Expand paletted images to rgb, expand grayscale images of
less then 8 bit depth to 8 bit depth, and expand tRNS chunks * less then 8 bit depth to 8 bit depth, and expand tRNS chunks
to alpha channels. */ * to alpha channels.
*/
void void
png_set_expand(png_structp png_ptr) png_set_expand(png_structp png_ptr)
{ {
@ -515,8 +577,9 @@ png_set_gray_to_rgb(png_structp png_ptr)
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
/* Convert a RGB image to a grayscale of the given width. This would /* Convert a RGB image to a grayscale of the given width. This would
allow us, for example, to convert a 24 bpp RGB image into an 8 or * allow us, for example, to convert a 24 bpp RGB image into an 8 or
16 bpp grayscale image. (Not yet implemented.) */ * 16 bpp grayscale image. (Not yet implemented.)
*/
void void
png_set_rgb_to_gray(png_structp png_ptr, int gray_bits) png_set_rgb_to_gray(png_structp png_ptr, int gray_bits)
{ {
@ -527,7 +590,8 @@ png_set_rgb_to_gray(png_structp png_ptr, int gray_bits)
#endif #endif
/* Initialize everything needed for the read. This includes modifying /* Initialize everything needed for the read. This includes modifying
the palette */ * the palette.
*/
void void
png_init_read_transformations(png_structp png_ptr) png_init_read_transformations(png_structp png_ptr)
{ {
@ -810,8 +874,9 @@ png_init_read_transformations(png_structp png_ptr)
} }
/* Modify the info structure to reflect the transformations. The /* Modify the info structure to reflect the transformations. The
info should be updated so a PNG file could be written with it, * info should be updated so a PNG file could be written with it,
assuming the transformations result in valid PNG data. */ * assuming the transformations result in valid PNG data.
*/
void void
png_read_transform_info(png_structp png_ptr, png_infop info_ptr) png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
{ {
@ -910,9 +975,10 @@ png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
(png_size_t)((info_ptr->width * info_ptr->pixel_depth + 7) >> 3); (png_size_t)((info_ptr->width * info_ptr->pixel_depth + 7) >> 3);
} }
/* transform the row. The order of transformations is significant, /* Transform the row. The order of transformations is significant,
and is very touchy. If you add a transformation, take care to * and is very touchy. If you add a transformation, take care to
decide how it fits in with the other transformations here. */ * decide how it fits in with the other transformations here.
*/
void void
png_do_read_transformations(png_structp png_ptr) png_do_read_transformations(png_structp png_ptr)
{ {
@ -955,7 +1021,9 @@ png_do_read_transformations(png_structp png_ptr)
#endif #endif
#if defined(PNG_READ_BACKGROUND_SUPPORTED) #if defined(PNG_READ_BACKGROUND_SUPPORTED)
if (png_ptr->transformations & PNG_BACKGROUND) if ((png_ptr->transformations & PNG_BACKGROUND) &&
((png_ptr->num_trans != 0 ) ||
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1, png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
&(png_ptr->trans_values), &(png_ptr->background), &(png_ptr->trans_values), &(png_ptr->background),
&(png_ptr->background_1), &(png_ptr->background_1),
@ -1041,11 +1109,12 @@ png_do_read_transformations(png_structp png_ptr)
} }
#if defined(PNG_READ_PACK_SUPPORTED) #if defined(PNG_READ_PACK_SUPPORTED)
/* unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, /* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
without changing the actual values. Thus, if you had a row with * without changing the actual values. Thus, if you had a row with
a bit depth of 1, you would end up with bytes that only contained * a bit depth of 1, you would end up with bytes that only contained
the numbers 0 or 1. If you would rather they contain 0 and 255, use * the numbers 0 or 1. If you would rather they contain 0 and 255, use
png_do_shift() after this. */ * png_do_shift() after this.
*/
void void
png_do_unpack(png_row_infop row_info, png_bytep row) png_do_unpack(png_row_infop row_info, png_bytep row)
{ {
@ -1131,10 +1200,11 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
#endif #endif
#if defined(PNG_READ_SHIFT_SUPPORTED) #if defined(PNG_READ_SHIFT_SUPPORTED)
/* reverse the effects of png_do_shift. This routine merely shifts the /* Reverse the effects of png_do_shift. This routine merely shifts the
pixels back to their significant bits values. Thus, if you have * pixels back to their significant bits values. Thus, if you have
a row of bit depth 8, but only 5 are significant, this will shift * a row of bit depth 8, but only 5 are significant, this will shift
the values back to 0 through 31 */ * the values back to 0 through 31.
*/
void void
png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits) png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
{ {
@ -1268,7 +1338,7 @@ png_do_chop(png_row_infop row_info, png_bytep row)
* *
* What the ideal calculation should be: * What the ideal calculation should be:
*dp = (((((png_uint_32)(*sp) << 8) | *dp = (((((png_uint_32)(*sp) << 8) |
(png_uint_32)(*(sp + 1))) * 255 + 127) / 65535; (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;
* Approximate calculation with shift/add instead of multiply/divide: * Approximate calculation with shift/add instead of multiply/divide:
*dp = ((((png_uint_32)(*sp) << 8) | *dp = ((((png_uint_32)(*sp) << 8) |
@ -1527,10 +1597,11 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
} }
#endif #endif
/* build a grayscale palette. Palette is assumed to be 1 << bit_depth /* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
large of png_color. This lets grayscale images be treated as * large of png_color. This lets grayscale images be treated as
paletted. Most useful for gamma correction and simplification * paletted. Most useful for gamma correction and simplification
of code. */ * of code.
*/
void void
png_build_grayscale_palette(int bit_depth, png_colorp palette) png_build_grayscale_palette(int bit_depth, png_colorp palette)
{ {
@ -1762,8 +1833,9 @@ png_correct_palette(png_structp png_ptr, png_colorp palette,
#if defined(PNG_READ_BACKGROUND_SUPPORTED) #if defined(PNG_READ_BACKGROUND_SUPPORTED)
/* Replace any alpha or transparency with the supplied background color. /* Replace any alpha or transparency with the supplied background color.
"background" is already in the screen gamma, while "background_1" is * "background" is already in the screen gamma, while "background_1" is
at a gamma of 1.0. Paletted files have already been taken care of. */ * at a gamma of 1.0. Paletted files have already been taken care of.
*/
void void
png_do_background(png_row_infop row_info, png_bytep row, png_do_background(png_row_infop row_info, png_bytep row,
png_color_16p trans_values, png_color_16p background, png_color_16p trans_values, png_color_16p background,
@ -2330,7 +2402,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
png_composite_16(v, g, a, background->green); png_composite_16(v, g, a, background->green);
*(dp + 2) = (png_byte)((v >> 8) & 0xff); *(dp + 2) = (png_byte)((v >> 8) & 0xff);
*(dp + 3) = (png_byte)(v & 0xff); *(dp + 3) = (png_byte)(v & 0xff);
png_composite_16(v, g, a, background->green); png_composite_16(v, b, a, background->blue);
*(dp + 4) = (png_byte)((v >> 8) & 0xff); *(dp + 4) = (png_byte)((v >> 8) & 0xff);
*(dp + 5) = (png_byte)(v & 0xff); *(dp + 5) = (png_byte)(v & 0xff);
} }
@ -2356,10 +2428,11 @@ png_do_background(png_row_infop row_info, png_bytep row,
#if defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED)
/* Gamma correct the image, avoiding the alpha channel. Make sure /* Gamma correct the image, avoiding the alpha channel. Make sure
you do this after you deal with the trasparency issue on grayscale * you do this after you deal with the trasparency issue on grayscale
or rgb images. If your bit depth is 8, use gamma_table, if it * or rgb images. If your bit depth is 8, use gamma_table, if it
is 16, use gamma_16_table and gamma_shift. Build these with * is 16, use gamma_16_table and gamma_shift. Build these with
build_gamma_table(). */ * build_gamma_table().
*/
void void
png_do_gamma(png_row_infop row_info, png_bytep row, png_do_gamma(png_row_infop row_info, png_bytep row,
png_bytep gamma_table, png_uint_16pp gamma_16_table, png_bytep gamma_table, png_uint_16pp gamma_16_table,
@ -2488,8 +2561,8 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
int msb = *sp & 0xf0; int msb = *sp & 0xf0;
int lsb = *sp & 0x0f; int lsb = *sp & 0x0f;
*sp = (((int)gamma_table[msb | msb >> 4] + 8) & 0xf0) | *sp = (((int)gamma_table[msb | (msb >> 4)]) & 0xf0) |
(((int)gamma_table[lsb << 4 | lsb] + 8) >> 4); (((int)gamma_table[(lsb << 4) | lsb]) >> 4);
sp++; sp++;
} }
} }
@ -2521,8 +2594,9 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
#endif #endif
#if defined(PNG_READ_EXPAND_SUPPORTED) #if defined(PNG_READ_EXPAND_SUPPORTED)
/* expands a palette row to an rgb or rgba row depending /* Expands a palette row to an rgb or rgba row depending
upon whether you supply trans and num_trans */ * upon whether you supply trans and num_trans.
*/
void void
png_do_expand_palette(png_row_infop row_info, png_bytep row, png_do_expand_palette(png_row_infop row_info, png_bytep row,
png_colorp palette, png_bytep trans, int num_trans) png_colorp palette, png_bytep trans, int num_trans)
@ -2662,8 +2736,9 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
} }
} }
/* if the bit depth < 8, it is expanded to 8. Also, if the /* If the bit depth < 8, it is expanded to 8. Also, if the
transparency value is supplied, an alpha channel is built. */ * transparency value is supplied, an alpha channel is built.
*/
void void
png_do_expand(png_row_infop row_info, png_bytep row, png_do_expand(png_row_infop row_info, png_bytep row,
png_color_16p trans_value) png_color_16p trans_value)
@ -2958,9 +3033,10 @@ static int png_gamma_shift[] =
{0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0}; {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0};
/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
tables, we don't make a full table if we are reducing to 8-bit in * tables, we don't make a full table if we are reducing to 8-bit in
the future. Note also how the gamma_16 tables are segmented so that * the future. Note also how the gamma_16 tables are segmented so that
we don't need to allocate > 64K chunks for a full 16-bit table. */ * we don't need to allocate > 64K chunks for a full 16-bit table.
*/
void void
png_build_gamma_table(png_structp png_ptr) png_build_gamma_table(png_structp png_ptr)
{ {

201
pngrutil.c
View File

@ -1,12 +1,15 @@
/* pngrutil.c - utilities to read a PNG file /* pngrutil.c - utilities to read a PNG file
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ *
* This file contains routines which are only called from within
* libpng itself during the course of reading an image.
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
@ -57,59 +60,6 @@ png_get_uint_16(png_bytep buf)
} }
#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */ #endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */
/* Set the action on getting a CRC error for an ancillary or critical chunk. */
void
png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
{
png_debug(1, "in png_set_crc_action\n");
/* Tell libpng how we react to CRC errors in critical chunks */
switch (crit_action)
{
case PNG_CRC_NO_CHANGE: /* leave setting as is */
break;
case PNG_CRC_WARN_USE: /* warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
break;
case PNG_CRC_QUIET_USE: /* quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
PNG_FLAG_CRC_CRITICAL_IGNORE;
break;
case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */
png_warning(png_ptr, "Can't discard critical data on CRC error.");
case PNG_CRC_ERROR_QUIT: /* error/quit */
case PNG_CRC_DEFAULT:
default:
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
break;
}
switch (ancil_action)
{
case PNG_CRC_NO_CHANGE: /* leave setting as is */
break;
case PNG_CRC_WARN_USE: /* warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
break;
case PNG_CRC_QUIET_USE: /* quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
PNG_FLAG_CRC_ANCILLARY_NOWARN;
break;
case PNG_CRC_ERROR_QUIT: /* error/quit */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
break;
case PNG_CRC_WARN_DISCARD: /* warn/discard data */
case PNG_CRC_DEFAULT:
default:
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
break;
}
}
/* Read data, and (optionally) run it through the CRC. */ /* Read data, and (optionally) run it through the CRC. */
void void
png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
@ -185,11 +135,7 @@ png_crc_error(png_structp png_ptr)
if (need_crc) if (need_crc)
{ {
crc = png_get_uint_32(crc_bytes); crc = png_get_uint_32(crc_bytes);
#ifdef PNG_USE_OWN_CRC
return (((crc^0xffffffffL)&0xffffffffL) != (png_ptr->crc&0xffffffffL));
#else
return (crc != png_ptr->crc); return (crc != png_ptr->crc);
#endif
} }
else else
return 0; return 0;
@ -228,7 +174,8 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
interlace_type = buf[12]; interlace_type = buf[12];
/* check for width and height valid values */ /* check for width and height valid values */
if (width == 0 || width > 2147483647 || height == 0 || height > 2147483647) if (width == 0 || width > (png_uint_32)2147483647L || height == 0 ||
height > (png_uint_32)2147483647L)
png_error(png_ptr, "Invalid image size in IHDR"); png_error(png_ptr, "Invalid image size in IHDR");
/* check other values */ /* check other values */
@ -246,7 +193,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
png_error(png_ptr, "Invalid color type/bit depth combination in IHDR"); png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");
if (interlace_type > PNG_INTERLACE_ADAM7) if (interlace_type >= PNG_INTERLACE_LAST)
png_error(png_ptr, "Unknown interlace method in IHDR"); png_error(png_ptr, "Unknown interlace method in IHDR");
if (compression_type != PNG_COMPRESSION_TYPE_BASE) if (compression_type != PNG_COMPRESSION_TYPE_BASE)
@ -337,7 +284,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
num = (int)length / 3; num = (int)length / 3;
palette = (png_colorp)png_malloc(png_ptr, num * sizeof (png_color)); palette = (png_colorp)png_zalloc(png_ptr, num, sizeof (png_color));
png_ptr->flags |= PNG_FLAG_FREE_PALETTE; png_ptr->flags |= PNG_FLAG_FREE_PALETTE;
for (i = 0; i < num; i++) for (i = 0; i < num; i++)
{ {
@ -457,6 +404,26 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
if (igamma == 0) if (igamma == 0)
return; return;
#if defined(PNG_READ_sRGB_SUPPORTED)
if ((png_ptr->mode & PNG_HAVE_sRGB))
if(igamma != 50000)
{
png_warning(png_ptr,
"Ignoring incorrect gAMA value when sRGB is also present");
return;
}
#endif /* PNG_READ_sRGB_SUPPORTED */
#if defined(PNG_READ_sRGB_SUPPORTED)
if (png_ptr->mode & PNG_HAVE_sRGB)
if(igamma != 50000)
{
png_warning(png_ptr,
"Ignoring incorrect gAMA value when sRGB is also present");
return;
}
#endif /* PNG_READ_sRGB_SUPPORTED */
file_gamma = (float)igamma / (float)100000.0; file_gamma = (float)igamma / (float)100000.0;
png_ptr->gamma = file_gamma; png_ptr->gamma = file_gamma;
png_set_gAMA(png_ptr, info_ptr, file_gamma); png_set_gAMA(png_ptr, info_ptr, file_gamma);
@ -483,8 +450,10 @@ png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
} }
else if (png_ptr->mode & PNG_HAVE_PLTE) else if (png_ptr->mode & PNG_HAVE_PLTE)
{
/* Should be an error, but we can cope with it */ /* Should be an error, but we can cope with it */
png_warning(png_ptr, "Out of place sBIT chunk"); png_warning(png_ptr, "Out of place sBIT chunk");
}
else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sBIT) else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sBIT)
{ {
png_warning(png_ptr, "Duplicate sBIT chunk"); png_warning(png_ptr, "Duplicate sBIT chunk");
@ -545,7 +514,8 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
else if (png_ptr->mode & PNG_HAVE_PLTE) else if (png_ptr->mode & PNG_HAVE_PLTE)
/* Should be an error, but we can cope with it */ /* Should be an error, but we can cope with it */
png_warning(png_ptr, "Missing PLTE before cHRM"); png_warning(png_ptr, "Missing PLTE before cHRM");
else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_cHRM) else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_cHRM
&& !(info_ptr->valid & PNG_INFO_sRGB))
{ {
png_warning(png_ptr, "Duplicate cHRM chunk"); png_warning(png_ptr, "Duplicate cHRM chunk");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
@ -626,11 +596,92 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
if (png_crc_finish(png_ptr, 0)) if (png_crc_finish(png_ptr, 0))
return; return;
#if defined(PNG_READ_sRGB_SUPPORTED)
if ((png_ptr->mode & PNG_HAVE_sRGB))
if(white_x != .3127 || white_y != .329 || red_x != .64 || red_y != .33 ||
green_x != .3 || green_y != .6 || blue_x != .15 || blue_y != .06)
{
png_warning(png_ptr,
"Ignoring incorrect cHRM value when sRGB is also present");
return;
}
#endif /* PNG_READ_sRGB_SUPPORTED */
png_set_cHRM(png_ptr, info_ptr, png_set_cHRM(png_ptr, info_ptr,
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 #endif
#if defined(PNG_READ_sRGB_SUPPORTED)
void
png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_byte intent;
png_byte buf[1];
float file_gamma;
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
png_debug(1, "in png_handle_sRGB\n");
if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before sRGB");
else if (png_ptr->mode & PNG_HAVE_IDAT)
{
png_warning(png_ptr, "Invalid sRGB after IDAT");
png_crc_finish(png_ptr, length);
return;
}
else if (png_ptr->mode & PNG_HAVE_PLTE)
/* Should be an error, but we can cope with it */
png_warning(png_ptr, "Out of place sRGB chunk");
else if (info_ptr != NULL && info_ptr->valid & PNG_INFO_sRGB)
{
png_warning(png_ptr, "Duplicate sRGB chunk");
png_crc_finish(png_ptr, length);
return;
}
if (length != 1)
{
png_warning(png_ptr, "Incorrect sRGB chunk length");
png_crc_finish(png_ptr, length);
return;
}
png_crc_read(png_ptr, buf, 1);
if (png_crc_finish(png_ptr, 0))
return;
intent = buf[0];
/* check for bad intent */
if (intent > 3)
{
png_warning(png_ptr, "Unknown sRGB intent");
return;
}
/* if we really want to be paranoid we could check for
already defined gamma and chrm with values that are
inconsistent with sRGB -- for now, just ignore them */
file_gamma = 0.45;
png_set_gAMA(png_ptr, info_ptr, file_gamma);
white_x = 0.3127;
white_y = 0.3290;
red_x = 0.6400;
red_y = 0.3300;
green_x = 0.3000;
green_y = 0.6000;
blue_x = 0.1500;
blue_y = 0.0600;
png_set_cHRM(png_ptr, info_ptr,
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
png_set_sRGB(png_ptr, info_ptr, intent);
}
#endif
#if defined(PNG_READ_tRNS_SUPPORTED) #if defined(PNG_READ_tRNS_SUPPORTED)
void void
png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
@ -683,7 +734,7 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
png_crc_read(png_ptr, buf, (png_size_t)length); png_crc_read(png_ptr, buf, (png_size_t)length);
png_ptr->num_trans = 3; png_ptr->num_trans = 1;
png_ptr->trans_values.red = png_get_uint_16(buf); png_ptr->trans_values.red = png_get_uint_16(buf);
png_ptr->trans_values.green = png_get_uint_16(buf + 2); png_ptr->trans_values.green = png_get_uint_16(buf + 2);
png_ptr->trans_values.blue = png_get_uint_16(buf + 4); png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
@ -1113,11 +1164,11 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
if (length > 65535L) if (length > (png_uint_32)65535L)
{ {
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); png_warning(png_ptr, "tEXt chunk too large to fit in memory");
skip = length - 65535L; skip = length - (png_uint_32)65535L;
length = 65535L; length = (png_uint_32)65535L;
} }
#endif #endif
@ -1171,7 +1222,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
/* We will no doubt have problems with chunks even half this size, but /* We will no doubt have problems with chunks even half this size, but
there is no hard and fast rule to tell us where to stop. */ there is no hard and fast rule to tell us where to stop. */
if (length > 65535L) if (length > (png_uint_32)65535L)
{ {
png_warning(png_ptr,"zTXt chunk too large to fit in memory"); png_warning(png_ptr,"zTXt chunk too large to fit in memory");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
@ -2113,13 +2164,13 @@ png_read_start_row(png_structp png_ptr)
rowbytes = ((rowbytes * (png_uint_32)max_pixel_depth + 7) >> 3) + rowbytes = ((rowbytes * (png_uint_32)max_pixel_depth + 7) >> 3) +
1 + ((max_pixel_depth + 7) >> 3); 1 + ((max_pixel_depth + 7) >> 3);
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
if (rowbytes > 65536L) if (rowbytes > (png_uint_32)65536L)
png_error(png_ptr, "This image requires a row greater than 64KB"); png_error(png_ptr, "This image requires a row greater than 64KB");
#endif #endif
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, rowbytes); png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, rowbytes);
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
if (png_ptr->rowbytes + 1 > 65536L) if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)
png_error(png_ptr, "This image requires a row greater than 64KB"); png_error(png_ptr, "This image requires a row greater than 64KB");
#endif #endif
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1); png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);

74
pngset.c
View File

@ -1,12 +1,17 @@
/* pngset.c - storage of image information into info struct /* pngset.c - storage of image information into info struct
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ *
* The functions here are used during reads to store data from the file
* into the info struct, and during writes to store application data
* into the info struct for writing into the file. This abstracts the
* info struct and allows us to change the structure in the future.
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
@ -205,8 +210,57 @@ png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
} }
#endif #endif
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) || \ #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) void
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, png_byte intent)
{
png_debug1(1, "in %s storage function\n", "sRGB");
if (info_ptr == NULL)
return;
info_ptr->srgb_intent = intent;
info_ptr->valid |= PNG_INFO_sRGB;
}
void
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
png_byte intent)
{
#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
float file_gamma;
#endif
#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
#endif
png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
if (info_ptr == NULL)
return;
png_set_sRGB(png_ptr, info_ptr, intent);
#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED)
file_gamma = 0.45;
png_set_gAMA(png_ptr, info_ptr, file_gamma);
#endif
#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED)
white_x = 0.3127;
white_y = 0.3290;
red_x = 0.6400;
red_y = 0.3300;
green_x = 0.3000;
green_y = 0.6000;
blue_x = 0.1500;
blue_y = 0.0600;
png_set_cHRM(png_ptr, info_ptr,
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
#endif
}
#endif
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED)
void void
png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
int num_text) int num_text)
@ -304,6 +358,8 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
{ {
png_memcpy(&(info_ptr->trans_values), trans_values, png_memcpy(&(info_ptr->trans_values), trans_values,
sizeof(png_color_16)); sizeof(png_color_16));
if (num_trans == 0)
num_trans = 1;
} }
info_ptr->num_trans = (png_uint_16)num_trans; info_ptr->num_trans = (png_uint_16)num_trans;
info_ptr->valid |= PNG_INFO_tRNS; info_ptr->valid |= PNG_INFO_tRNS;

50
pngtest.c
View File

@ -1,12 +1,30 @@
/* pngtest.c - a simple test program to test libpng /* pngtest.c - a simple test program to test libpng
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ *
* This program reads in a PNG image, writes it out again, and then
* compares the two files. If the files are identical, this shows that
* the basic chunk handling, filtering, and (de)compression code is working
* properly. It does not currently test all of the transforms, although
* it probably should.
*
* The program will fail in certain legitimate cases:
* 1) when the compression level or filter selection method is changed.
* 2) when the chunk size is smaller than 8K.
* 3) unknown ancillary chunks exist in the input file.
* 4) others not listed here...
* In these cases, it is best to check with another tool such as "pngcheck"
* to see what the differences between the two images are.
*
* If a filename is given on the command-line, then this file is used
* for the input, rather than the default "pngtest.png". This allows
* testing a wide variety of files easily.
*/
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -28,11 +46,11 @@
/* input and output filenames */ /* input and output filenames */
#ifdef RISCOS #ifdef RISCOS
char *inname = "pngtest_png"; PNG_CONST char *inname = "pngtest_png";
char *outname = "pngout_png"; PNG_CONST char *outname = "pngout_png";
#else #else
char *inname = "pngtest.png"; PNG_CONST char *inname = "pngtest.png";
char *outname = "pngout.png"; PNG_CONST char *outname = "pngout.png";
#endif #endif
char inbuf[256], outbuf[256]; char inbuf[256], outbuf[256];
@ -182,6 +200,16 @@ main(int argc, char *argv[])
} }
} }
#endif #endif
#if defined(PNG_READ_sRGB_SUPPORTED) && defined(PNG_WRITE_sRGB_SUPPORTED)
{
png_byte intent;
if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
{
png_set_sRGB(write_ptr, write_info_ptr, intent);
}
}
#endif
#if defined(PNG_READ_hIST_SUPPORTED) && defined(PNG_WRITE_hIST_SUPPORTED) #if defined(PNG_READ_hIST_SUPPORTED) && defined(PNG_WRITE_hIST_SUPPORTED)
{ {
png_uint_16p hist; png_uint_16p hist;

14
pngtrans.c
View File

@ -1,12 +1,12 @@
/* pngtrans.c - transforms the data in a row (used by both readers and writers) /* pngtrans.c - transforms the data in a row (used by both readers and writers)
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"

27
pngwio.c
View File

@ -1,18 +1,19 @@
/* pngwio.c - functions for data output /* pngwio.c - functions for data output
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*
This file provides a location for all output. Users which need * This file provides a location for all output. Users which need
special handling are expected to write functions which have the same * special handling are expected to write functions which have the same
arguments as these, and perform similar functions, but possibly use * arguments as these, and perform similar functions, but possibly use
different output methods. Note that you shouldn't change these * different output methods. Note that you shouldn't change these
functions, but rather write replacement functions and then change * functions, but rather write replacement functions and then change
them at run time with png_set_write_fn(...) */ * them at run time with png_set_write_fn(...).
*/
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"

90
pngwrite.c
View File

@ -1,12 +1,12 @@
/* pngwrite.c - general routines to write a PNG file /* pngwrite.c - general routines to write a PNG file
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
/* get internal access to png.h */ /* get internal access to png.h */
#define PNG_INTERNAL #define PNG_INTERNAL
@ -38,6 +38,10 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_gAMA) if (info_ptr->valid & PNG_INFO_gAMA)
png_write_gAMA(png_ptr, info_ptr->gamma); png_write_gAMA(png_ptr, info_ptr->gamma);
#endif #endif
#if defined(PNG_WRITE_sRGB_SUPPORTED)
if (info_ptr->valid & PNG_INFO_sRGB)
png_write_sRGB(png_ptr, info_ptr->srgb_intent);
#endif
#if defined(PNG_WRITE_sBIT_SUPPORTED) #if defined(PNG_WRITE_sBIT_SUPPORTED)
if (info_ptr->valid & PNG_INFO_sBIT) if (info_ptr->valid & PNG_INFO_sBIT)
png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
@ -128,9 +132,10 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
} }
/* Writes the end of the PNG file. If you don't want to write comments or /* Writes the end of the PNG file. If you don't want to write comments or
time information, you can pass NULL for info. If you already wrote these * time information, you can pass NULL for info. If you already wrote these
in png_write_info(), do not write them again here. If you have long * in png_write_info(), do not write them again here. If you have long
comments, I suggest writing them here, and compressing them. */ * comments, I suggest writing them here, and compressing them.
*/
void void
png_write_end(png_structp png_ptr, png_infop info_ptr) png_write_end(png_structp png_ptr, png_infop info_ptr)
{ {
@ -190,6 +195,28 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
png_write_IEND(png_ptr); png_write_IEND(png_ptr);
} }
#if defined(PNG_TIME_RFC1152_SUPPORTED)
/* Convert the supplied time into an RFC 1152 string suitable for use in
* a "Creation Time" or other text-based time string.
*/
png_charp
png_convert_to_rfc1152(png_structp png_ptr, png_timep ptime)
{
const char *short_months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
if (png_ptr->time_buffer == NULL)
{
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, 29*sizeof(char));
}
sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
ptime->day % 31, short_months[ptime->month], ptime->year,
ptime->hour % 24, ptime->minute % 60, ptime->second % 61);
return png_ptr->time_buffer;
}
#endif /* PNG_TIME_RFC1152_SUPPORTED */
#if defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_WRITE_tIME_SUPPORTED)
void void
png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime) png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
@ -261,6 +288,11 @@ png_create_write_struct(png_const_charp user_png_ver, voidp error_ptr,
png_set_write_fn(png_ptr, NULL, NULL, NULL); png_set_write_fn(png_ptr, NULL, NULL, NULL);
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
1, NULL, NULL);
#endif
return (png_ptr); return (png_ptr);
} }
@ -292,10 +324,11 @@ png_write_init(png_structp png_ptr)
#endif #endif
} }
/* write a few rows of image data. If the image is interlaced, /* 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 * either you will have to write the 7 sub images, or, if you
have called png_set_interlace_handling(), you will have to * have called png_set_interlace_handling(), you will have to
"write" the image seven times */ * "write" the image seven times.
*/
void void
png_write_rows(png_structp png_ptr, png_bytepp row, png_write_rows(png_structp png_ptr, png_bytepp row,
png_uint_32 num_rows) png_uint_32 num_rows)
@ -311,8 +344,9 @@ png_write_rows(png_structp png_ptr, png_bytepp row,
} }
} }
/* write the image. You only need to call this function once, even /* Write the image. You only need to call this function once, even
if you are writing an interlaced image. */ * if you are writing an interlaced image.
*/
void void
png_write_image(png_structp png_ptr, png_bytepp image) png_write_image(png_structp png_ptr, png_bytepp image)
{ {
@ -339,7 +373,8 @@ png_write_image(png_structp png_ptr, png_bytepp image)
void void
png_write_row(png_structp png_ptr, png_bytep row) png_write_row(png_structp png_ptr, png_bytep row)
{ {
png_debug(1, "in png_write_row\n"); png_debug2(1, "in png_write_row (row %ld, pass %d)\n",
png_ptr->row_number, png_ptr->pass);
/* initialize transformations and other stuff if first time */ /* initialize transformations and other stuff if first time */
if (png_ptr->row_number == 0 && png_ptr->pass == 0) if (png_ptr->row_number == 0 && png_ptr->pass == 0)
{ {
@ -415,12 +450,12 @@ png_write_row(png_structp png_ptr, png_bytep row)
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
png_debug1(4, "row_info->color_type = %d\n", png_ptr->row_info.color_type); png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
png_debug1(4, "row_info->width = %d\n", png_ptr->row_info.width); png_debug1(3, "row_info->width = %d\n", png_ptr->row_info.width);
png_debug1(4, "row_info->channels = %d\n", png_ptr->row_info.channels); png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);
png_debug1(4, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth); png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
png_debug1(4, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth); png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
png_debug1(4, "row_info->rowbytes = %d\n", png_ptr->row_info.rowbytes); png_debug1(3, "row_info->rowbytes = %d\n", png_ptr->row_info.rowbytes);
/* Copy user's row into buffer, leaving room for filter byte. */ /* Copy user's row into buffer, leaving room for filter byte. */
png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes); png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes);
@ -527,6 +562,9 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
if (info_ptr != NULL) if (info_ptr != NULL)
{ {
#ifdef PNG_WRITE_tEXt_SUPPORTED
png_free(png_ptr, info_ptr->text);
#endif
png_destroy_struct((png_voidp)info_ptr); png_destroy_struct((png_voidp)info_ptr);
*info_ptr_ptr = (png_infop)NULL; *info_ptr_ptr = (png_infop)NULL;
} }
@ -561,6 +599,9 @@ png_write_destroy(png_structp png_ptr)
png_free(png_ptr, png_ptr->up_row); png_free(png_ptr, png_ptr->up_row);
png_free(png_ptr, png_ptr->avg_row); png_free(png_ptr, png_ptr->avg_row);
png_free(png_ptr, png_ptr->paeth_row); png_free(png_ptr, png_ptr->paeth_row);
#if defined(PNG_TIME_RFC1152_SUPPORTED)
png_free(png_ptr, png_ptr->time_buffer);
#endif /* PNG_TIME_RFC1152_SUPPORTED */
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
png_free(png_ptr, png_ptr->prev_filters); png_free(png_ptr, png_ptr->prev_filters);
png_free(png_ptr, png_ptr->filter_weights); png_free(png_ptr, png_ptr->filter_weights);
@ -683,7 +724,8 @@ png_set_filter(png_structp png_ptr, int method, int filters)
* differences metric is relatively fast and effective, there is some * differences metric is relatively fast and effective, there is some
* question as to whether it can be improved upon by trying to keep the * question as to whether it can be improved upon by trying to keep the
* filtered data going to zlib more consistent, hopefully resulting in * filtered data going to zlib more consistent, hopefully resulting in
* better compression. */ * better compression.
*/
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */ #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */
void void
png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,

43
pngwtran.c
View File

@ -1,18 +1,19 @@
/* pngwtran.c - transforms the data in a row for PNG writers /* pngwtran.c - transforms the data in a row for PNG writers
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
/* transform the data according to the users wishes. The order of /* Transform the data according to the users wishes. The order of
transformations is significant. */ * transformations is significant.
*/
void void
png_do_write_transformations(png_structp png_ptr) png_do_write_transformations(png_structp png_ptr)
{ {
@ -51,9 +52,10 @@ png_do_write_transformations(png_structp png_ptr)
} }
#if defined(PNG_WRITE_PACK_SUPPORTED) #if defined(PNG_WRITE_PACK_SUPPORTED)
/* pack pixels into bytes. Pass the true bit depth in bit_depth. The /* Pack pixels into bytes. Pass the true bit depth in bit_depth. The
row_info bit depth should be 8 (one pixel per byte). The channels * row_info bit depth should be 8 (one pixel per byte). The channels
should be 1 (this only happens on grayscale and paletted images) */ * should be 1 (this only happens on grayscale and paletted images).
*/
void void
png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
{ {
@ -169,12 +171,13 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
#endif #endif
#if defined(PNG_WRITE_SHIFT_SUPPORTED) #if defined(PNG_WRITE_SHIFT_SUPPORTED)
/* shift pixel values to take advantage of whole range. Pass the /* Shift pixel values to take advantage of whole range. Pass the
true number of bits in bit_depth. The row should be packed * true number of bits in bit_depth. The row should be packed
according to row_info->bit_depth. Thus, if you had a row of * according to row_info->bit_depth. Thus, if you had a row of
bit depth 4, but the pixels only had values from 0 to 7, you * bit depth 4, but the pixels only had values from 0 to 7, you
would pass 3 as bit_depth, and this routine would translate the * would pass 3 as bit_depth, and this routine would translate the
data to 0 to 15. */ * data to 0 to 15.
*/
void void
png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
{ {
@ -252,7 +255,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
for (bp = row, i = 0; i < row_info->width; i++) for (bp = row, i = 0; i < row_info->width; i++)
{ {
int c; png_uint_32 c;
for (c = 0; c < channels; c++, bp++) for (c = 0; c < channels; c++, bp++)
{ {
@ -278,7 +281,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
for (bp = row, i = 0; i < row_info->width * row_info->channels; i++) for (bp = row, i = 0; i < row_info->width * row_info->channels; i++)
{ {
int c; png_uint_32 c;
for (c = 0; c < channels; c++, bp += 2) for (c = 0; c < channels; c++, bp += 2)
{ {

128
pngwutil.c
View File

@ -1,12 +1,12 @@
/* pngwutil.c - utilities to write a PNG file /* pngwutil.c - utilities to write a PNG file
*
libpng 1.0 beta 6 - version 0.96 * libpng 1.00.97
For conditions of distribution and use, see copyright notice in png.h * 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.
Copyright (c) 1996, 1997 Andreas Dilger * Copyright (c) 1996, 1997 Andreas Dilger
May 12, 1997 * May 28, 1997
*/ */
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
@ -26,8 +26,9 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)
#if defined(PNG_WRITE_pCAL_SUPPORTED) #if defined(PNG_WRITE_pCAL_SUPPORTED)
/* The png_save_int_32 function assumes integers are stored in two's /* The png_save_int_32 function assumes integers are stored in two's
complement format. If this isn't the case, then this routine needs to * complement format. If this isn't the case, then this routine needs to
be modified to write data in two's complement format. */ * be modified to write data in two's complement format.
*/
void void
png_save_int_32(png_bytep buf, png_int_32 i) png_save_int_32(png_bytep buf, png_int_32 i)
{ {
@ -38,22 +39,26 @@ png_save_int_32(png_bytep buf, png_int_32 i)
} }
#endif #endif
/* Place a 16-bit number into a buffer in PNG byte order. */ /* Place a 16-bit number into a buffer in PNG byte order.
* The parameter is declared unsigned int, not png_uint_16,
* just to avoid potential problems on pre-ANSI C compilers.
*/
void void
png_save_uint_16(png_bytep buf, png_uint_16 i) png_save_uint_16(png_bytep buf, unsigned int i)
{ {
buf[0] = (png_byte)((i >> 8) & 0xff); buf[0] = (png_byte)((i >> 8) & 0xff);
buf[1] = (png_byte)(i & 0xff); buf[1] = (png_byte)(i & 0xff);
} }
/* Write a PNG chunk all at once. The type is an array of ASCII characters /* Write a PNG chunk all at once. The type is an array of ASCII characters
representing the chunk name. The array must be at least 4 bytes in * representing the chunk name. The array must be at least 4 bytes in
length, and does not need to be null terminated. To be safe, pass the * length, and does not need to be null terminated. To be safe, pass the
pre-defined chunk names here, and if you need a new one, define it * pre-defined chunk names here, and if you need a new one, define it
where the others are defined. The length is the length of the data. * where the others are defined. The length is the length of the data.
All the data must be present. If that is not possible, use the * All the data must be present. If that is not possible, use the
png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
functions instead. */ * functions instead.
*/
void void
png_write_chunk(png_structp png_ptr, png_bytep chunk_name, png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
png_bytep data, png_size_t length) png_bytep data, png_size_t length)
@ -64,8 +69,9 @@ png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
} }
/* Write the start of a PNG chunk. The type is the chunk type. /* Write the start of a PNG chunk. The type is the chunk type.
The total_length is the sum of the lengths of all the data you will be * The total_length is the sum of the lengths of all the data you will be
passing in png_write_chunk_data() */ * passing in png_write_chunk_data().
*/
void void
png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name, png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
png_uint_32 length) png_uint_32 length)
@ -85,9 +91,10 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
} }
/* Write the data of a PNG chunk started with png_write_chunk_start(). /* Write the data of a PNG chunk started with png_write_chunk_start().
Note that multiple calls to this function are allowed, and that the * Note that multiple calls to this function are allowed, and that the
sum of the lengths from these calls *must* add up to the total_length * sum of the lengths from these calls *must* add up to the total_length
given to png_write_chunk_start(). */ * given to png_write_chunk_start().
*/
void void
png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length) png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
@ -106,11 +113,7 @@ png_write_chunk_end(png_structp png_ptr)
png_byte buf[4]; png_byte buf[4];
/* write the crc */ /* write the crc */
#ifdef PNG_USE_OWN_CRC
png_save_uint_32(buf, ~png_ptr->crc);
#else
png_save_uint_32(buf, png_ptr->crc); png_save_uint_32(buf, png_ptr->crc);
#endif
png_write_data(png_ptr, buf, (png_size_t)4); png_write_data(png_ptr, buf, (png_size_t)4);
} }
@ -119,7 +122,8 @@ png_write_chunk_end(png_structp png_ptr)
* the magic bytes of the signature, or more likely, the PNG stream is * the magic bytes of the signature, or more likely, the PNG stream is
* being embedded into another stream and doesn't need its own signature, * being embedded into another stream and doesn't need its own signature,
* we should call png_set_sig_bytes() to tell libpng how many of the * we should call png_set_sig_bytes() to tell libpng how many of the
* bytes have already been written. */ * bytes have already been written.
*/
void void
png_write_sig(png_structp png_ptr) png_write_sig(png_structp png_ptr)
{ {
@ -129,8 +133,9 @@ png_write_sig(png_structp png_ptr)
} }
/* Write the IHDR chunk, and update the png_struct with the necessary /* Write the IHDR chunk, and update the png_struct with the necessary
information. Note that the rest of this code depends upon this * information. Note that the rest of this code depends upon this
information being correct. */ * information being correct.
*/
void void
png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
int bit_depth, int color_type, int compression_type, int filter_type, int bit_depth, int color_type, int compression_type, int filter_type,
@ -264,8 +269,9 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
} }
/* write the palette. We are careful not to trust png_color to be in the /* write the palette. We are careful not to trust png_color to be in the
correct order for PNG, so people can redefine it to any convient * correct order for PNG, so people can redefine it to any convient
structure. */ * structure.
*/
void void
png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal) png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
{ {
@ -336,6 +342,22 @@ png_write_gAMA(png_structp png_ptr, double file_gamma)
} }
#endif #endif
#if defined(PNG_WRITE_sRGB_SUPPORTED)
/* write a sRGB chunk */
void
png_write_sRGB(png_structp png_ptr, png_byte srgb_intent)
{
png_byte buf[1];
png_debug(1, "in png_write_sRGB\n");
if(srgb_intent > 3)
png_warning(png_ptr,
"Invalid sRGB rendering intent specified");
buf[0]=srgb_intent;
png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
}
#endif
#if defined(PNG_WRITE_sBIT_SUPPORTED) #if defined(PNG_WRITE_sBIT_SUPPORTED)
/* write the sBIT chunk */ /* write the sBIT chunk */
void void
@ -560,11 +582,10 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, png_uint_32 num_hist)
* static keywords without having to have duplicate copies of the strings. * static keywords without having to have duplicate copies of the strings.
*/ */
png_size_t png_size_t
png_check_keyword(png_structp png_ptr, png_charp key, png_bytepp new_key) png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
{ {
png_size_t key_len; png_size_t key_len;
png_charp kp; png_charp kp, dp;
png_bytep dp;
int kflag; int kflag;
png_debug(1, "in png_check_keyword\n"); png_debug(1, "in png_check_keyword\n");
@ -581,12 +602,12 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_bytepp new_key)
png_debug1(2, "Keyword to be checked is '%s'\n", key); png_debug1(2, "Keyword to be checked is '%s'\n", key);
*new_key = (png_bytep)png_malloc(png_ptr, key_len + 1); *new_key = (png_charp)png_malloc(png_ptr, key_len + 1);
/* Replace non-printing characters with a blank and print a warning */ /* Replace non-printing characters with a blank and print a warning */
for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)
{ {
if (*kp < 0x20 || ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1)) if (*kp < 0x20 || (*kp > 0x7E && *kp < 0xA1))
{ {
char msg[40]; char msg[40];
@ -688,7 +709,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len) png_size_t text_len)
{ {
png_size_t key_len; png_size_t key_len;
png_bytep new_key; png_charp new_key;
png_debug(1, "in png_write_tEXt\n"); png_debug(1, "in png_write_tEXt\n");
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
@ -705,7 +726,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
/* make sure we include the 0 after the key */ /* make sure we include the 0 after the key */
png_write_chunk_start(png_ptr, png_tEXt, (png_uint_32)key_len+text_len+1); png_write_chunk_start(png_ptr, png_tEXt, (png_uint_32)key_len+text_len+1);
png_write_chunk_data(png_ptr, new_key, key_len + 1); png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
if (text_len) if (text_len)
png_write_chunk_data(png_ptr, (png_bytep)text, text_len); png_write_chunk_data(png_ptr, (png_bytep)text, text_len);
@ -722,7 +743,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
{ {
png_size_t key_len; png_size_t key_len;
char buf[1]; char buf[1];
png_bytep new_key; png_charp new_key;
int i, ret; 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 num_output_ptr = 0; /* number of output pointers used */
@ -945,7 +966,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
png_size_t purpose_len, units_len, total_len; png_size_t purpose_len, units_len, total_len;
png_uint_32p params_len; png_uint_32p params_len;
png_byte buf[10]; png_byte buf[10];
png_bytep new_purpose; png_charp new_purpose;
int i; int i;
png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams); png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);
@ -971,7 +992,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
png_debug1(3, "pCAL total length = %d\n", total_len); png_debug1(3, "pCAL total length = %d\n", total_len);
png_write_chunk_start(png_ptr, png_pCAL, total_len); png_write_chunk_start(png_ptr, png_pCAL, total_len);
png_write_chunk_data(png_ptr, new_purpose, purpose_len); png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len);
png_save_int_32(buf, X0); png_save_int_32(buf, X0);
png_save_int_32(buf + 4, X1); png_save_int_32(buf + 4, X1);
buf[8] = (png_byte)type; buf[8] = (png_byte)type;
@ -1013,8 +1034,9 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
#endif #endif
#if defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_WRITE_tIME_SUPPORTED)
/* write the tIME chunk. Use either png_convert_from_struct_tm() /* Write the tIME chunk. Use either png_convert_from_struct_tm()
or png_convert_from_time_t(), or fill in the structure yourself */ * or png_convert_from_time_t(), or fill in the structure yourself.
*/
void void
png_write_tIME(png_structp png_ptr, png_timep mod_time) png_write_tIME(png_structp png_ptr, png_timep mod_time)
{ {
@ -1206,14 +1228,13 @@ png_write_finish_row(png_structp png_ptr)
} }
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* pick out the correct pixels for the interlace pass. /* Pick out the correct pixels for the interlace pass.
* The basic idea here is to go through the row with a source
The basic idea here is to go through the row with a source * pointer and a destination pointer (sp and dp), and copy the
pointer and a destination pointer (sp and dp), and copy the * correct pixels for the pass. As the row gets compacted,
correct pixels for the pass. As the row gets compacted, * sp will always be >= dp, so we should never overwrite anything.
sp will always be >= dp, so we should never overwrite anything. * See the default: case for the easiest code to understand.
See the default: case for the easiest code to understand. */
*/
void void
png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
{ {
@ -1366,7 +1387,8 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
/* This filters the row, chooses which filter to use, if it has not already /* This filters the row, chooses which filter to use, if it has not already
* been specified by the application, and then writes the row out with the * been specified by the application, and then writes the row out with the
* chosen filter. */ * chosen filter.
*/
#define PNG_MAXSUM (~0x0UL >> 1) #define PNG_MAXSUM (~0x0UL >> 1)
#define PNG_HISHIFT 10 #define PNG_HISHIFT 10
#define PNG_LOMASK 0xffffL #define PNG_LOMASK 0xffffL