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

Imported from libpng-1.2.37beta03.tar

Browse Source
This commit is contained in:
Glenn Randers-Pehrson 2009-05-20 12:43:52 -05:00
parent c0d53e176b
commit e5ee05dc0d
66 changed files with 1969 additions and 1613 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
ANNOUNCE
View File

@ -1,5 +1,5 @@
Libpng 1.2.37rc01 - May 19, 2009 Libpng 1.2.37beta03 - May 20, 2009
This is not intended to be a public release. It will be replaced This is not intended to be a public release. It will be replaced
within a few weeks by a public version or by another test version. within a few weeks by a public version or by another test version.
@ -9,37 +9,37 @@ Files available for download:
Source files with LF line endings (for Unix/Linux) and with a Source files with LF line endings (for Unix/Linux) and with a
"configure" script "configure" script
libpng-1.2.37rc01.tar.gz libpng-1.2.37beta03.tar.gz
libpng-1.2.37rc01.tar.lzma libpng-1.2.37beta03.tar.lzma
(Get the lzma codec from <http://tukaani.org/lzma>). (Get the lzma codec from <http://tukaani.org/lzma>).
libpng-1.2.37rc01.tar.bz2 libpng-1.2.37beta03.tar.bz2
Source files with LF line endings (for Unix/Linux) without the Source files with LF line endings (for Unix/Linux) without the
"configure" script "configure" script
libpng-1.2.37rc01-no-config.tar.gz libpng-1.2.37beta03-no-config.tar.gz
libpng-1.2.37rc01-no-config.tar.lzma libpng-1.2.37beta03-no-config.tar.lzma
libpng-1.2.37rc01-no-config.tar.bz2 libpng-1.2.37beta03-no-config.tar.bz2
Source files with CRLF line endings (for Windows), without the Source files with CRLF line endings (for Windows), without the
"configure" script "configure" script
lp1237r01.zip lp1237b03.zip
lp1237r01.7z lp1237b03.7z
lp1237r01.tar.bz2 lp1237b03.tar.bz2
Project files Project files
libpng-1.2.37rc01-project-netware.zip libpng-1.2.37beta03-project-netware.zip
libpng-1.2.37rc01-project-wince.zip libpng-1.2.37beta03-project-wince.zip
Other information: Other information:
libpng-1.2.37rc01-README.txt libpng-1.2.37beta03-README.txt
libpng-1.2.37rc01-KNOWNBUGS.txt libpng-1.2.37beta03-KNOWNBUGS.txt
libpng-1.2.37rc01-LICENSE.txt libpng-1.2.37beta03-LICENSE.txt
libpng-1.2.37rc01-Y2K-compliance.txt libpng-1.2.37beta03-Y2K-compliance.txt
libpng-1.2.37rc01-[previous version]-diff.txt libpng-1.2.37beta03-[previous version]-diff.txt
Changes since the last public release (1.2.36): Changes since the last public release (1.2.36):
@ -59,7 +59,11 @@ version 1.2.37beta02 [May 19, 2009]
Added contrib/pngminim/preader to demonstrate building minimal progressive Added contrib/pngminim/preader to demonstrate building minimal progressive
decoder, based on contrib/gregbook with embedded libpng and zlib. decoder, based on contrib/gregbook with embedded libpng and zlib.
version 1.2.37rc01 [May 19, 2009] version 1.2.37beta03 [May 20, 2009]
In contrib/pngminim/*, renamed "makefile.std" to "makefile", since there
is only one makefile in those directories, and revised the README files
accordingly.
Reformated sources in libpng style (3-space indentation, comment format)
Send comments/corrections/commendations to png-mng-implement at lists.sf.net Send comments/corrections/commendations to png-mng-implement at lists.sf.net

7
CHANGES
View File

@ -2384,7 +2384,12 @@ version 1.2.37beta02 [May 19, 2009]
Added contrib/pngminim/preader to demonstrate building minimal progressive Added contrib/pngminim/preader to demonstrate building minimal progressive
decoder, based on contrib/gregbook with embedded libpng and zlib. decoder, based on contrib/gregbook with embedded libpng and zlib.
version 1.2.37rc01 [May 19, 2009] version 1.2.37beta03 [May 20, 2009]
In contrib/pngminim/*, renamed "makefile.std" to "makefile", since there
is only one makefile in those directories, and revised the README files
accordingly.
Reformated sources in libpng style (3-space indentation, comment format)
Send comments/corrections/commendations to png-mng-implement at lists.sf.net Send comments/corrections/commendations to png-mng-implement at lists.sf.net
(subscription required; visit (subscription required; visit

16
INSTALL
View File

@ -1,5 +1,5 @@
Installing libpng version 1.2.37rc01 - May 19, 2009 Installing libpng version 1.2.37beta03 - May 20, 2009
On Unix/Linux and similar systems, you can simply type On Unix/Linux and similar systems, you can simply type
@ -44,7 +44,7 @@ to have access to the zlib.h and zconf.h include files that
correspond to the version of zlib that's installed. correspond to the version of zlib that's installed.
You can rename the directories that you downloaded (they You can rename the directories that you downloaded (they
might be called "libpng-1.2.37rc01" or "lpng109" and "zlib-1.2.1" might be called "libpng-1.2.37beta03" or "lpng109" and "zlib-1.2.1"
or "zlib121") so that you have directories called "zlib" and "libpng". or "zlib121") so that you have directories called "zlib" and "libpng".
Your directory structure should look like this: Your directory structure should look like this:
@ -101,9 +101,9 @@ include
CMakeLists.txt => "cmake" script CMakeLists.txt => "cmake" script
makefile.std => Generic UNIX makefile (cc, creates static libpng.a) makefile.std => Generic UNIX makefile (cc, creates static libpng.a)
makefile.elf => Linux/ELF makefile symbol versioning, makefile.elf => Linux/ELF makefile symbol versioning,
gcc, creates libpng12.so.0.1.2.37rc01) gcc, creates libpng12.so.0.1.2.37beta03)
makefile.linux => Linux/ELF makefile makefile.linux => Linux/ELF makefile
(gcc, creates libpng12.so.0.1.2.37rc01) (gcc, creates libpng12.so.0.1.2.37beta03)
makefile.gcc => Generic makefile (gcc, creates static libpng.a) makefile.gcc => Generic makefile (gcc, creates static libpng.a)
makefile.knr => Archaic UNIX Makefile that converts files with makefile.knr => Archaic UNIX Makefile that converts files with
ansi2knr (Requires ansi2knr.c from ansi2knr (Requires ansi2knr.c from
@ -125,14 +125,14 @@ include
makefile.openbsd => OpenBSD makefile makefile.openbsd => OpenBSD makefile
makefile.sgi => Silicon Graphics IRIX makefile (cc, creates static lib) makefile.sgi => Silicon Graphics IRIX makefile (cc, creates static lib)
makefile.sggcc => Silicon Graphics (gcc, makefile.sggcc => Silicon Graphics (gcc,
creates libpng12.so.0.1.2.37rc01) creates libpng12.so.0.1.2.37beta03)
makefile.sunos => Sun makefile makefile.sunos => Sun makefile
makefile.solaris => Solaris 2.X makefile (gcc, makefile.solaris => Solaris 2.X makefile (gcc,
creates libpng12.so.0.1.2.37rc01) creates libpng12.so.0.1.2.37beta03)
makefile.solaris-x86 => Solaris/intelMMX 2.X makefile (gcc, makefile.solaris-x86 => Solaris/intelMMX 2.X makefile (gcc,
creates libpng12.so.0.1.2.37rc01) creates libpng12.so.0.1.2.37beta03)
makefile.so9 => Solaris 9 makefile (gcc, makefile.so9 => Solaris 9 makefile (gcc,
creates libpng12.so.0.1.2.37rc01) creates libpng12.so.0.1.2.37beta03)
makefile.32sunu => Sun Ultra 32-bit makefile makefile.32sunu => Sun Ultra 32-bit makefile
makefile.64sunu => Sun Ultra 64-bit makefile makefile.64sunu => Sun Ultra 64-bit makefile
makefile.sco => For SCO OSr5 ELF and Unixware 7 with Native cc makefile.sco => For SCO OSr5 ELF and Unixware 7 with Native cc

2
KNOWNBUG
View File

@ -1,5 +1,5 @@
Known bugs in libpng version 1.2.37rc01 Known bugs in libpng version 1.2.37beta03
1. February 23, 2006: The custom makefiles don't build libpng with -lz. 1. February 23, 2006: The custom makefiles don't build libpng with -lz.

4
LICENSE
View File

@ -8,7 +8,7 @@ COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
If you modify libpng you may insert additional notices immediately following If you modify libpng you may insert additional notices immediately following
this sentence. this sentence.
libpng versions 1.2.6, August 15, 2004, through 1.2.37rc01, May 19, 2009, are libpng versions 1.2.6, August 15, 2004, through 1.2.37beta03, May 20, 2009, are
Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are
distributed according to the same disclaimer and license as libpng-1.2.5 distributed according to the same disclaimer and license as libpng-1.2.5
with the following individual added to the list of Contributing Authors with the following individual added to the list of Contributing Authors
@ -106,4 +106,4 @@ certification mark of the Open Source Initiative.
Glenn Randers-Pehrson Glenn Randers-Pehrson
glennrp at users.sourceforge.net glennrp at users.sourceforge.net
May 19, 2009 May 20, 2009

2
Makefile.am
View File

@ -86,7 +86,7 @@ EXTRA_DIST= \
${srcdir}/contrib/pngsuite/* \ ${srcdir}/contrib/pngsuite/* \
${srcdir}/contrib/visupng/* \ ${srcdir}/contrib/visupng/* \
$(TESTS) \ $(TESTS) \
example.c libpng-1.2.37rc01.txt pngvcrd.c example.c libpng-1.2.37beta03.txt pngvcrd.c
CLEANFILES= pngout.png libpng12.pc libpng12-config libpng.vers \ CLEANFILES= pngout.png libpng12.pc libpng12-config libpng.vers \
libpng.sym libpng.sym

2
Makefile.in
View File

@ -333,7 +333,7 @@ EXTRA_DIST = \
${srcdir}/contrib/pngsuite/* \ ${srcdir}/contrib/pngsuite/* \
${srcdir}/contrib/visupng/* \ ${srcdir}/contrib/visupng/* \
$(TESTS) \ $(TESTS) \
example.c libpng-1.2.37rc01.txt pngvcrd.c example.c libpng-1.2.37beta03.txt pngvcrd.c
CLEANFILES = pngout.png libpng12.pc libpng12-config libpng.vers \ CLEANFILES = pngout.png libpng12.pc libpng12-config libpng.vers \
libpng.sym libpng.sym

14
README
View File

@ -1,4 +1,4 @@
README for libpng version 1.2.37rc01 - May 19, 2009 (shared library 12.0) README for libpng version 1.2.37beta03 - May 20, 2009 (shared library 12.0)
See the note about version numbers near the top of png.h See the note about version numbers near the top of png.h
See INSTALL for instructions on how to install libpng. See INSTALL for instructions on how to install libpng.
@ -194,11 +194,11 @@ Files in this distribution:
descrip.mms => VMS makefile for MMS or MMK descrip.mms => VMS makefile for MMS or MMK
makefile.std => Generic UNIX makefile (cc, creates static libpng.a) makefile.std => Generic UNIX makefile (cc, creates static libpng.a)
makefile.elf => Linux/ELF makefile symbol versioning, makefile.elf => Linux/ELF makefile symbol versioning,
gcc, creates libpng12.so.0.1.2.37rc01) gcc, creates libpng12.so.0.1.2.37beta03)
makefile.linux => Linux/ELF makefile makefile.linux => Linux/ELF makefile
(gcc, creates libpng12.so.0.1.2.37rc01) (gcc, creates libpng12.so.0.1.2.37beta03)
makefile.gcmmx => Linux/ELF makefile makefile.gcmmx => Linux/ELF makefile
(gcc, creates libpng12.so.0.1.2.37rc01, (gcc, creates libpng12.so.0.1.2.37beta03,
uses assembler code tuned for Intel MMX platform) uses assembler code tuned for Intel MMX platform)
makefile.gcc => Generic makefile (gcc, creates static libpng.a) makefile.gcc => Generic makefile (gcc, creates static libpng.a)
makefile.knr => Archaic UNIX Makefile that converts files with makefile.knr => Archaic UNIX Makefile that converts files with
@ -220,12 +220,12 @@ Files in this distribution:
makefile.openbsd => OpenBSD makefile makefile.openbsd => OpenBSD makefile
makefile.sgi => Silicon Graphics IRIX (cc, creates static lib) makefile.sgi => Silicon Graphics IRIX (cc, creates static lib)
makefile.sggcc => Silicon Graphics makefile.sggcc => Silicon Graphics
(gcc, creates libpng12.so.0.1.2.37rc01) (gcc, creates libpng12.so.0.1.2.37beta03)
makefile.sunos => Sun makefile makefile.sunos => Sun makefile
makefile.solaris => Solaris 2.X makefile makefile.solaris => Solaris 2.X makefile
(gcc, creates libpng12.so.0.1.2.37rc01) (gcc, creates libpng12.so.0.1.2.37beta03)
makefile.so9 => Solaris 9 makefile makefile.so9 => Solaris 9 makefile
(gcc, creates libpng12.so.0.1.2.37rc01) (gcc, creates libpng12.so.0.1.2.37beta03)
makefile.32sunu => Sun Ultra 32-bit makefile makefile.32sunu => Sun Ultra 32-bit makefile
makefile.64sunu => Sun Ultra 64-bit makefile makefile.64sunu => Sun Ultra 64-bit makefile
makefile.sco => For SCO OSr5 ELF and Unixware 7 with Native cc makefile.sco => For SCO OSr5 ELF and Unixware 7 with Native cc

4
Y2KINFO
View File

@ -1,13 +1,13 @@
Y2K compliance in libpng: Y2K compliance in libpng:
========================= =========================
May 19, 2009 May 20, 2009
Since the PNG Development group is an ad-hoc body, we can't make Since the PNG Development group is an ad-hoc body, we can't make
an official declaration. an official declaration.
This is your unofficial assurance that libpng from version 0.71 and This is your unofficial assurance that libpng from version 0.71 and
upward through 1.2.37rc01 are Y2K compliant. It is my belief that earlier upward through 1.2.37beta03 are Y2K compliant. It is my belief that earlier
versions were also Y2K compliant. versions were also Y2K compliant.
Libpng only has three year fields. One is a 2-byte unsigned integer Libpng only has three year fields. One is a 2-byte unsigned integer

22
configure vendored
View File

@ -1,6 +1,6 @@
#! /bin/sh #! /bin/sh
# Guess values for system-dependent variables and create Makefiles. # Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.62 for libpng 1.2.37rc01. # Generated by GNU Autoconf 2.62 for libpng 1.2.37beta03.
# #
# Report bugs to <png-mng-implement@lists.sourceforge.net>. # Report bugs to <png-mng-implement@lists.sourceforge.net>.
# #
@ -745,8 +745,8 @@ SHELL=${CONFIG_SHELL-/bin/sh}
# Identity of this package. # Identity of this package.
PACKAGE_NAME='libpng' PACKAGE_NAME='libpng'
PACKAGE_TARNAME='libpng' PACKAGE_TARNAME='libpng'
PACKAGE_VERSION='1.2.37rc01' PACKAGE_VERSION='1.2.37beta03'
PACKAGE_STRING='libpng 1.2.37rc01' PACKAGE_STRING='libpng 1.2.37beta03'
PACKAGE_BUGREPORT='png-mng-implement@lists.sourceforge.net' PACKAGE_BUGREPORT='png-mng-implement@lists.sourceforge.net'
ac_unique_file="pngget.c" ac_unique_file="pngget.c"
@ -1484,7 +1484,7 @@ if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing. # Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh. # This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF cat <<_ACEOF
\`configure' configures libpng 1.2.37rc01 to adapt to many kinds of systems. \`configure' configures libpng 1.2.37beta03 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]... Usage: $0 [OPTION]... [VAR=VALUE]...
@ -1554,7 +1554,7 @@ fi
if test -n "$ac_init_help"; then if test -n "$ac_init_help"; then
case $ac_init_help in case $ac_init_help in
short | recursive ) echo "Configuration of libpng 1.2.37rc01:";; short | recursive ) echo "Configuration of libpng 1.2.37beta03:";;
esac esac
cat <<\_ACEOF cat <<\_ACEOF
@ -1661,7 +1661,7 @@ fi
test -n "$ac_init_help" && exit $ac_status test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then if $ac_init_version; then
cat <<\_ACEOF cat <<\_ACEOF
libpng configure 1.2.37rc01 libpng configure 1.2.37beta03
generated by GNU Autoconf 2.62 generated by GNU Autoconf 2.62
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
@ -1675,7 +1675,7 @@ cat >config.log <<_ACEOF
This file contains any messages produced by compilers while This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake. running configure, to aid debugging if configure makes a mistake.
It was created by libpng $as_me 1.2.37rc01, which was It was created by libpng $as_me 1.2.37beta03, which was
generated by GNU Autoconf 2.62. Invocation command line was generated by GNU Autoconf 2.62. Invocation command line was
$ $0 $@ $ $0 $@
@ -2389,7 +2389,7 @@ fi
# Define the identity of the package. # Define the identity of the package.
PACKAGE='libpng' PACKAGE='libpng'
VERSION='1.2.37rc01' VERSION='1.2.37beta03'
cat >>confdefs.h <<_ACEOF cat >>confdefs.h <<_ACEOF
@ -2558,7 +2558,7 @@ fi
PNGLIB_VERSION=1.2.37rc01 PNGLIB_VERSION=1.2.37beta03
PNGLIB_MAJOR=1 PNGLIB_MAJOR=1
PNGLIB_MINOR=2 PNGLIB_MINOR=2
PNGLIB_RELEASE=37 PNGLIB_RELEASE=37
@ -13125,7 +13125,7 @@ exec 6>&1
# report actual input values of CONFIG_FILES etc. instead of their # report actual input values of CONFIG_FILES etc. instead of their
# values after options handling. # values after options handling.
ac_log=" ac_log="
This file was extended by libpng $as_me 1.2.37rc01, which was This file was extended by libpng $as_me 1.2.37beta03, which was
generated by GNU Autoconf 2.62. Invocation command line was generated by GNU Autoconf 2.62. Invocation command line was
CONFIG_FILES = $CONFIG_FILES CONFIG_FILES = $CONFIG_FILES
@ -13178,7 +13178,7 @@ Report bugs to <bug-autoconf@gnu.org>."
_ACEOF _ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_version="\\ ac_cs_version="\\
libpng config.status 1.2.37rc01 libpng config.status 1.2.37beta03
configured by $0, generated by GNU Autoconf 2.62, configured by $0, generated by GNU Autoconf 2.62,
with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\" with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"

4
configure.ac
View File

@ -18,12 +18,12 @@ AC_PREREQ(2.59)
dnl Version number stuff here: dnl Version number stuff here:
AC_INIT([libpng], [1.2.37rc01], [png-mng-implement@lists.sourceforge.net]) AC_INIT([libpng], [1.2.37beta03], [png-mng-implement@lists.sourceforge.net])
AM_INIT_AUTOMAKE AM_INIT_AUTOMAKE
dnl stop configure from automagically running automake dnl stop configure from automagically running automake
AM_MAINTAINER_MODE AM_MAINTAINER_MODE
PNGLIB_VERSION=1.2.37rc01 PNGLIB_VERSION=1.2.37beta03
PNGLIB_MAJOR=1 PNGLIB_MAJOR=1
PNGLIB_MINOR=2 PNGLIB_MINOR=2
PNGLIB_RELEASE=37 PNGLIB_RELEASE=37

4
contrib/pngminim/decoder/README
View File

@ -1,7 +1,9 @@
This demonstrates the use of PNG_USER_CONFIG and pngusr.h This demonstrates the use of PNG_USER_CONFIG and pngusr.h
To build a minimal read-only decoder, run To build a minimal read-only decoder with embedded libpng and zlib, run
gather.sh # to collect needed files from pngminus, libpng, and zlib gather.sh # to collect needed files from pngminus, libpng, and zlib
make make
If you prefer to use the shared libraries, go to contrib/pngminus
and build the png2pnm application there.

4
contrib/pngminim/encoder/README
View File

@ -1,7 +1,9 @@
This demonstrates the use of PNG_USER_CONFIG and pngusr.h This demonstrates the use of PNG_USER_CONFIG and pngusr.h
To build a minimal write-only encoder, run To build a minimal write-only decoder with embedded libpng and zlib, run
gather.sh # to collect needed files from pngminus, libpng, and zlib gather.sh # to collect needed files from pngminus, libpng, and zlib
make make
If you prefer to use the shared libraries, go to contrib/pngminus
and build the pnm2png application there.

5
contrib/pngminim/preader/README
View File

@ -1,6 +1,7 @@
This demonstrates the use of PNG_USER_CONFIG and pngusr.h This demonstrates the use of PNG_USER_CONFIG and pngusr.h
To build a minimal read-only progressive decoder with X display, run To build a minimal read-only progressive decoder embedded libpng and
zlib and with your system's X library, run
gather.sh # to collect needed files from gregbook, libpng, and zlib gather.sh # to collect needed files from gregbook, libpng, and zlib
@ -9,3 +10,5 @@ then
make make
If you prefer to use the shared libraries, go to contrib/gregbook
and build the rpng2-x application there.

42
example.c
View File

@ -2,7 +2,7 @@
#if 0 /* in case someone actually tries to compile this */ #if 0 /* in case someone actually tries to compile this */
/* example.c - an example of using libpng /* example.c - an example of using libpng
* Last changed in libpng 1.2.37 [May 19, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* This file has been placed in the public domain by the authors. * This file has been placed in the public domain by the authors.
* Maintained 1998-2009 Glenn Randers-Pehrson * Maintained 1998-2009 Glenn Randers-Pehrson
* Maintained 1996, 1997 Andreas Dilger) * Maintained 1996, 1997 Andreas Dilger)
@ -93,13 +93,13 @@ void read_png(char *file_name) /* We need to open the file */
return (ERROR); return (ERROR);
#else no_open_file /* prototype 2 */ #else no_open_file /* prototype 2 */
void read_png(FILE *fp, unsigned int sig_read) /* file is already open */ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
{ {
png_structp png_ptr; png_structp png_ptr;
png_infop info_ptr; png_infop info_ptr;
png_uint_32 width, height; png_uint_32 width, height;
int bit_depth, color_type, interlace_type; int bit_depth, color_type, interlace_type;
#endif no_open_file /* only use one prototype! */ #endif no_open_file /* Only use one prototype! */
/* Create and initialize the png_struct with the desired error handler /* Create and initialize the png_struct with the desired error handler
* functions. If you want to use the default stderr and longjump method, * functions. If you want to use the default stderr and longjump method,
@ -177,7 +177,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, int_p_NULL, int_p_NULL); &interlace_type, int_p_NULL, int_p_NULL);
/* Set up the data transformations you want. Note that these are all /* Set up the data transformations you want. Note that these are all
* optional. Only call them if you want/need them. Many of the * optional. Only call them if you want/need them. Many of the
* transformations only work on specific types of images, and many * transformations only work on specific types of images, and many
* are mutually exclusive. * are mutually exclusive.
@ -230,9 +230,9 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
png_set_background(png_ptr, &my_background, png_set_background(png_ptr, &my_background,
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
/* Some suggestions as to how to get a screen gamma value */ /* Some suggestions as to how to get a screen gamma value
*
/* Note that screen gamma is the display_exponent, which includes * Note that screen gamma is the display_exponent, which includes
* the CRT_exponent and any correction for viewing conditions * the CRT_exponent and any correction for viewing conditions
*/ */
if (/* We have a user-defined screen gamma value */) if (/* We have a user-defined screen gamma value */)
@ -280,7 +280,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
png_colorp palette; png_colorp palette;
/* This reduces the image to the application supplied palette */ /* This reduces the image to the application supplied palette */
if (/* we have our own palette */) if (/* We have our own palette */)
{ {
/* An array of colors to which the image should be dithered */ /* An array of colors to which the image should be dithered */
png_color std_color_cube[MAX_SCREEN_COLORS]; png_color std_color_cube[MAX_SCREEN_COLORS];
@ -377,13 +377,13 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
#else no_sparkle /* Read the image using the "rectangle" effect */ #else no_sparkle /* Read the image using the "rectangle" effect */
png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y], png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y],
number_of_rows); number_of_rows);
#endif no_sparkle /* use only one of these two methods */ #endif no_sparkle /* Use only one of these two methods */
} }
/* if you want to display the image after every pass, do so here */ /* If you want to display the image after every pass, do so here */
#endif no_single /* use only one of these two methods */ #endif no_single /* Use only one of these two methods */
} }
#endif no_entire /* use only one of these two methods */ #endif no_entire /* Use only one of these two methods */
/* Read rest of file, and get additional chunks in info_ptr - REQUIRED */ /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
png_read_end(png_ptr, info_ptr); png_read_end(png_ptr, info_ptr);
@ -397,7 +397,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
/* Close the file */ /* Close the file */
fclose(fp); fclose(fp);
/* that's it */ /* That's it */
return (OK); return (OK);
} }
@ -480,7 +480,7 @@ process_data(png_structp *png_ptr, png_infop *info_ptr,
info_callback(png_structp png_ptr, png_infop info) info_callback(png_structp png_ptr, png_infop info)
{ {
/* Do any setup here, including setting any of the transformations /* Do any setup here, including setting any of the transformations
* mentioned in the Reading PNG files section. For now, you _must_ * mentioned in the Reading PNG files section. For now, you _must_
* call either png_start_read_image() or png_read_update_info() * call either png_start_read_image() or png_read_update_info()
* after all the transformations are set (even if you don't set * after all the transformations are set (even if you don't set
@ -492,7 +492,7 @@ info_callback(png_structp png_ptr, png_infop info)
row_callback(png_structp png_ptr, png_bytep new_row, row_callback(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass) png_uint_32 row_num, int pass)
{ {
/* /*
* This function is called for every row in the image. If the * This function is called for every row in the image. If the
* image is interlaced, and you turned on the interlace handler, * image is interlaced, and you turned on the interlace handler,
* this function will be called for every row in every pass. * this function will be called for every row in every pass.
@ -508,6 +508,7 @@ row_callback(png_structp png_ptr, png_bytep new_row,
* png_progressive_combine_row() to replace the corresponding row as * png_progressive_combine_row() to replace the corresponding row as
* shown below: * shown below:
*/ */
/* Check if row_num is in bounds. */ /* Check if row_num is in bounds. */
if ((row_num >= 0) && (row_num < height)) if ((row_num >= 0) && (row_num < height))
{ {
@ -522,7 +523,7 @@ row_callback(png_structp png_ptr, png_bytep new_row,
if ((old_row != NULL) && (new_row != NULL)) if ((old_row != NULL) && (new_row != NULL))
png_progressive_combine_row(png_ptr, old_row, new_row); png_progressive_combine_row(png_ptr, old_row, new_row);
} }
/* /*
* The rows and passes are called in order, so you don't really * The rows and passes are called in order, so you don't really
* need the row_num and pass, but I'm supplying them because it * need the row_num and pass, but I'm supplying them because it
* may make your life easier. * may make your life easier.
@ -537,7 +538,7 @@ row_callback(png_structp png_ptr, png_bytep new_row,
png_progressive_combine_row(png_ptr, old_row, new_row); png_progressive_combine_row(png_ptr, old_row, new_row);
/* where old_row is what was displayed for previous rows. Note /* where old_row is what was displayed for previous rows. Note
* that the first pass (pass == 0 really) will completely cover * that the first pass (pass == 0 really) will completely cover
* the old row, so the rows do not have to be initialized. After * the old row, so the rows do not have to be initialized. After
* the first pass (and only for interlaced images), you will have * the first pass (and only for interlaced images), you will have
@ -548,7 +549,7 @@ row_callback(png_structp png_ptr, png_bytep new_row,
end_callback(png_structp png_ptr, png_infop info) end_callback(png_structp png_ptr, png_infop info)
{ {
/* This function is called when the whole image has been read, /* This function is called when the whole image has been read,
* including any chunks after the image (up to and including * including any chunks after the image (up to and including
* the IEND). You will usually have the same info chunk as you * the IEND). You will usually have the same info chunk as you
* had in the header, although some data may have been added * had in the header, although some data may have been added
@ -608,6 +609,7 @@ void write_png(char *file_name /* , ... other image information ... */)
} }
/* One of the following I/O initialization functions is REQUIRED */ /* One of the following I/O initialization functions is REQUIRED */
#ifdef streams /* I/O initialization method 1 */ #ifdef streams /* I/O initialization method 1 */
/* Set up the output control if you are using standard C streams */ /* Set up the output control if you are using standard C streams */
png_init_io(png_ptr, fp); png_init_io(png_ptr, fp);
@ -619,7 +621,7 @@ void write_png(char *file_name /* , ... other image information ... */)
png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn, png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
user_IO_flush_function); user_IO_flush_function);
/* 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 */
#endif no_streams /* only use one initialization method */ #endif no_streams /* Only use one initialization method */
#ifdef hilevel #ifdef hilevel
/* This is the easy way. Use it if you already have all the /* This is the easy way. Use it if you already have all the
@ -771,7 +773,7 @@ void write_png(char *file_name /* , ... other image information ... */)
#ifdef entire /* Write out the entire image data in one call */ #ifdef entire /* Write out the entire image data in one call */
png_write_image(png_ptr, row_pointers); png_write_image(png_ptr, row_pointers);
/* the other way to write the image - deal with interlacing */ /* The other way to write the image - deal with interlacing */
#else no_entire /* Write out the image data by one or more scanlines */ #else no_entire /* Write out the image data by one or more scanlines */

8
libpng-1.2.37rc01.txt → libpng-1.2.37beta03.txt
View File

@ -1,6 +1,6 @@
libpng.txt - A description on how to use and modify libpng libpng.txt - A description on how to use and modify libpng
libpng version 1.2.37rc01 - May 19, 2009 libpng version 1.2.37beta03 - May 20, 2009
Updated and distributed by Glenn Randers-Pehrson Updated and distributed by Glenn Randers-Pehrson
<glennrp at users.sourceforge.net> <glennrp at users.sourceforge.net>
Copyright (c) 1998-2009 Glenn Randers-Pehrson Copyright (c) 1998-2009 Glenn Randers-Pehrson
@ -9,7 +9,7 @@ libpng.txt - A description on how to use and modify libpng
Based on: Based on:
libpng versions 0.97, January 1998, through 1.2.37rc01 - May 19, 2009 libpng versions 0.97, January 1998, through 1.2.37beta03 - May 20, 2009
Updated and distributed by Glenn Randers-Pehrson Updated and distributed by Glenn Randers-Pehrson
Copyright (c) 1998-2009 Glenn Randers-Pehrson Copyright (c) 1998-2009 Glenn Randers-Pehrson
@ -2947,13 +2947,13 @@ when the Intel assembler code was removed due to a licensing issue.
IX. (Omitted) IX. (Omitted)
X. Y2K Compliance in libpng X. Y2K Compliance in libpng
May 19, 2009 May 20, 2009
Since the PNG Development group is an ad-hoc body, we can't make Since the PNG Development group is an ad-hoc body, we can't make
an official declaration. an official declaration.
This is your unofficial assurance that libpng from version 0.71 and This is your unofficial assurance that libpng from version 0.71 and
upward through 1.2.37rc01 are Y2K compliant. It is my belief that earlier upward through 1.2.37beta03 are Y2K compliant. It is my belief that earlier
versions were also Y2K compliant. versions were also Y2K compliant.
Libpng only has three year fields. One is a 2-byte unsigned integer that Libpng only has three year fields. One is a 2-byte unsigned integer that

20
libpng.3
View File

@ -1,6 +1,6 @@
.TH LIBPNG 3 "May 19, 2009" .TH LIBPNG 3 "May 20, 2009"
.SH NAME .SH NAME
libpng \- Portable Network Graphics (PNG) Reference Library 1.2.37rc01 libpng \- Portable Network Graphics (PNG) Reference Library 1.2.37beta03
.SH SYNOPSIS .SH SYNOPSIS
\fI\fB \fI\fB
@ -821,7 +821,7 @@ Following is a copy of the libpng.txt file that accompanies libpng.
.SH LIBPNG.TXT .SH LIBPNG.TXT
libpng.txt - A description on how to use and modify libpng libpng.txt - A description on how to use and modify libpng
libpng version 1.2.37rc01 - May 19, 2009 libpng version 1.2.37beta03 - May 20, 2009
Updated and distributed by Glenn Randers-Pehrson Updated and distributed by Glenn Randers-Pehrson
<glennrp at users.sourceforge.net> <glennrp at users.sourceforge.net>
Copyright (c) 1998-2009 Glenn Randers-Pehrson Copyright (c) 1998-2009 Glenn Randers-Pehrson
@ -830,7 +830,7 @@ libpng.txt - A description on how to use and modify libpng
Based on: Based on:
libpng versions 0.97, January 1998, through 1.2.37rc01 - May 19, 2009 libpng versions 0.97, January 1998, through 1.2.37beta03 - May 20, 2009
Updated and distributed by Glenn Randers-Pehrson Updated and distributed by Glenn Randers-Pehrson
Copyright (c) 1998-2009 Glenn Randers-Pehrson Copyright (c) 1998-2009 Glenn Randers-Pehrson
@ -3768,13 +3768,13 @@ when the Intel assembler code was removed due to a licensing issue.
.SH IX. (Omitted) .SH IX. (Omitted)
.SH X. Y2K Compliance in libpng .SH X. Y2K Compliance in libpng
May 19, 2009 May 20, 2009
Since the PNG Development group is an ad-hoc body, we can't make Since the PNG Development group is an ad-hoc body, we can't make
an official declaration. an official declaration.
This is your unofficial assurance that libpng from version 0.71 and This is your unofficial assurance that libpng from version 0.71 and
upward through 1.2.37rc01 are Y2K compliant. It is my belief that earlier upward through 1.2.37beta03 are Y2K compliant. It is my belief that earlier
versions were also Y2K compliant. versions were also Y2K compliant.
Libpng only has three year fields. One is a 2-byte unsigned integer that Libpng only has three year fields. One is a 2-byte unsigned integer that
@ -4040,7 +4040,7 @@ the first widely used release:
1.2.36rc01 13 10236 12.so.0.36[.0] 1.2.36rc01 13 10236 12.so.0.36[.0]
1.0.44 10 10044 10.so.0.44[.0] 1.0.44 10 10044 10.so.0.44[.0]
1.2.36 13 10236 12.so.0.36[.0] 1.2.36 13 10236 12.so.0.36[.0]
1.2.37rc01 13 10237 12.so.0.37[.0] 1.2.37beta01-03 13 10237 12.so.0.37[.0]
Henceforth the source version will match the shared-library minor Henceforth the source version will match the shared-library minor
and patch numbers; the shared-library major version number will be and patch numbers; the shared-library major version number will be
@ -4096,7 +4096,7 @@ possible without all of you.
Thanks to Frank J. T. Wojcik for helping with the documentation. Thanks to Frank J. T. Wojcik for helping with the documentation.
Libpng version 1.2.37rc01 - May 19, 2009: Libpng version 1.2.37beta03 - May 20, 2009:
Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc. Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc.
Currently maintained by Glenn Randers-Pehrson (glennrp at users.sourceforge.net). Currently maintained by Glenn Randers-Pehrson (glennrp at users.sourceforge.net).
@ -4117,7 +4117,7 @@ included in the libpng distribution, the latter shall prevail.)
If you modify libpng you may insert additional notices immediately following If you modify libpng you may insert additional notices immediately following
this sentence. this sentence.
libpng versions 1.2.6, August 15, 2004, through 1.2.37rc01, May 19, 2009, are libpng versions 1.2.6, August 15, 2004, through 1.2.37beta03, May 20, 2009, are
Copyright (c) 2004,2006-2008 Glenn Randers-Pehrson, and are Copyright (c) 2004,2006-2008 Glenn Randers-Pehrson, and are
distributed according to the same disclaimer and license as libpng-1.2.5 distributed according to the same disclaimer and license as libpng-1.2.5
with the following individual added to the list of Contributing Authors with the following individual added to the list of Contributing Authors
@ -4216,7 +4216,7 @@ certification mark of the Open Source Initiative.
Glenn Randers-Pehrson Glenn Randers-Pehrson
glennrp at users.sourceforge.net glennrp at users.sourceforge.net
May 19, 2009 May 20, 2009
.\" end of man page .\" end of man page

4
libpngpf.3
View File

@ -1,6 +1,6 @@
.TH LIBPNGPF 3 "May 19, 2009" .TH LIBPNGPF 3 "May 20, 2009"
.SH NAME .SH NAME
libpng \- Portable Network Graphics (PNG) Reference Library 1.2.37rc01 libpng \- Portable Network Graphics (PNG) Reference Library 1.2.37beta03
(private functions) (private functions)
.SH SYNOPSIS .SH SYNOPSIS
\fB#include <png.h>\fP \fB#include <png.h>\fP

2
png.5
View File

@ -1,4 +1,4 @@
.TH PNG 5 "May 19, 2009" .TH PNG 5 "May 20, 2009"
.SH NAME .SH NAME
png \- Portable Network Graphics (PNG) format png \- Portable Network Graphics (PNG) format
.SH DESCRIPTION .SH DESCRIPTION

188
png.c
View File

@ -1,9 +1,9 @@
/* png.c - location for general purpose libpng functions /* png.c - location for general purpose libpng functions
* *
* Last changed in libpng 1.2.34 [December 18, 2008] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@ -13,7 +13,7 @@
#include "png.h" #include "png.h"
/* Generate a compiler error if there is an old png.h in the search path. */ /* Generate a compiler error if there is an old png.h in the search path. */
typedef version_1_2_37rc01 Your_png_h_is_not_version_1_2_37rc01; typedef version_1_2_37beta03 Your_png_h_is_not_version_1_2_37beta03;
/* 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. */
@ -53,18 +53,18 @@ PNG_tRNS;
PNG_zTXt; PNG_zTXt;
#ifdef PNG_READ_SUPPORTED #ifdef PNG_READ_SUPPORTED
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST 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 */
PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
/* Height of interlace block. This is not currently used - if you need /* Height of interlace block. This is not currently used - if you need
@ -92,7 +92,8 @@ PNG_CONST int FARDATA png_pass_dsp_mask[]
void PNGAPI void PNGAPI
png_set_sig_bytes(png_structp png_ptr, int num_bytes) png_set_sig_bytes(png_structp png_ptr, int num_bytes)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_debug(1, "in png_set_sig_bytes"); png_debug(1, "in png_set_sig_bytes");
if (num_bytes > 8) if (num_bytes > 8)
png_error(png_ptr, "Too many bytes for PNG signature."); png_error(png_ptr, "Too many bytes for PNG signature.");
@ -153,7 +154,8 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
png_uint_32 save_flags=p->flags; png_uint_32 save_flags=p->flags;
png_uint_32 num_bytes; png_uint_32 num_bytes;
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
if (items > PNG_UINT_32_MAX/size) if (items > PNG_UINT_32_MAX/size)
{ {
png_warning (p, "Potential overflow in png_zalloc()"); png_warning (p, "Potential overflow in png_zalloc()");
@ -183,7 +185,7 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
return ((voidpf)ptr); return ((voidpf)ptr);
} }
/* function to free memory for zlib */ /* Function to free memory for zlib */
#ifdef PNG_1_0_X #ifdef PNG_1_0_X
void PNGAPI void PNGAPI
#else #else
@ -241,7 +243,8 @@ png_create_info_struct(png_structp png_ptr)
png_infop info_ptr; png_infop info_ptr;
png_debug(1, "in png_create_info_struct"); png_debug(1, "in png_create_info_struct");
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
png_ptr->malloc_fn, png_ptr->mem_ptr); png_ptr->malloc_fn, png_ptr->mem_ptr);
@ -263,7 +266,8 @@ void PNGAPI
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)
{ {
png_infop info_ptr = NULL; png_infop info_ptr = NULL;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_debug(1, "in png_destroy_info_struct"); png_debug(1, "in png_destroy_info_struct");
if (info_ptr_ptr != NULL) if (info_ptr_ptr != NULL)
@ -302,7 +306,8 @@ png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
{ {
png_infop info_ptr = *ptr_ptr; png_infop info_ptr = *ptr_ptr;
if (info_ptr == NULL) return; if (info_ptr == NULL)
return;
png_debug(1, "in png_info_init_3"); png_debug(1, "in png_info_init_3");
@ -313,7 +318,7 @@ png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
*ptr_ptr = info_ptr; *ptr_ptr = info_ptr;
} }
/* set everything to 0 */ /* Set everything to 0 */
png_memset(info_ptr, 0, png_sizeof(png_info)); png_memset(info_ptr, 0, png_sizeof(png_info));
} }
@ -344,13 +349,13 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
return; return;
#if defined(PNG_TEXT_SUPPORTED) #if defined(PNG_TEXT_SUPPORTED)
/* free text item num or (if num == -1) all text items */ /* Free text item num or (if num == -1) all text items */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_TEXT) if (mask & PNG_FREE_TEXT)
#endif #endif
{ {
if (num != -1) if (num != -1)
{ {
if (info_ptr->text && info_ptr->text[num].key) if (info_ptr->text && info_ptr->text[num].key)
@ -368,34 +373,34 @@ if (mask & PNG_FREE_TEXT)
info_ptr->text = NULL; info_ptr->text = NULL;
info_ptr->num_text=0; info_ptr->num_text=0;
} }
} }
#endif #endif
#if defined(PNG_tRNS_SUPPORTED) #if defined(PNG_tRNS_SUPPORTED)
/* free any tRNS entry */ /* Free any tRNS entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
#else #else
if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
#endif #endif
{ {
png_free(png_ptr, info_ptr->trans); png_free(png_ptr, info_ptr->trans);
info_ptr->trans = NULL; info_ptr->trans = NULL;
info_ptr->valid &= ~PNG_INFO_tRNS; info_ptr->valid &= ~PNG_INFO_tRNS;
#ifndef PNG_FREE_ME_SUPPORTED #ifndef PNG_FREE_ME_SUPPORTED
png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
#endif #endif
} }
#endif #endif
#if defined(PNG_sCAL_SUPPORTED) #if defined(PNG_sCAL_SUPPORTED)
/* free any sCAL entry */ /* Free any sCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_SCAL) if (mask & PNG_FREE_SCAL)
#endif #endif
{ {
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
png_free(png_ptr, info_ptr->scal_s_width); png_free(png_ptr, info_ptr->scal_s_width);
png_free(png_ptr, info_ptr->scal_s_height); png_free(png_ptr, info_ptr->scal_s_height);
@ -403,17 +408,17 @@ if (mask & PNG_FREE_SCAL)
info_ptr->scal_s_height = NULL; info_ptr->scal_s_height = NULL;
#endif #endif
info_ptr->valid &= ~PNG_INFO_sCAL; info_ptr->valid &= ~PNG_INFO_sCAL;
} }
#endif #endif
#if defined(PNG_pCAL_SUPPORTED) #if defined(PNG_pCAL_SUPPORTED)
/* free any pCAL entry */ /* Free any pCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_PCAL) if (mask & PNG_FREE_PCAL)
#endif #endif
{ {
png_free(png_ptr, info_ptr->pcal_purpose); png_free(png_ptr, info_ptr->pcal_purpose);
png_free(png_ptr, info_ptr->pcal_units); png_free(png_ptr, info_ptr->pcal_units);
info_ptr->pcal_purpose = NULL; info_ptr->pcal_purpose = NULL;
@ -430,33 +435,33 @@ if (mask & PNG_FREE_PCAL)
info_ptr->pcal_params = NULL; info_ptr->pcal_params = NULL;
} }
info_ptr->valid &= ~PNG_INFO_pCAL; info_ptr->valid &= ~PNG_INFO_pCAL;
} }
#endif #endif
#if defined(PNG_iCCP_SUPPORTED) #if defined(PNG_iCCP_SUPPORTED)
/* free any iCCP entry */ /* Free any iCCP entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_ICCP) if (mask & PNG_FREE_ICCP)
#endif #endif
{ {
png_free(png_ptr, info_ptr->iccp_name); png_free(png_ptr, info_ptr->iccp_name);
png_free(png_ptr, info_ptr->iccp_profile); png_free(png_ptr, info_ptr->iccp_profile);
info_ptr->iccp_name = NULL; info_ptr->iccp_name = NULL;
info_ptr->iccp_profile = NULL; info_ptr->iccp_profile = NULL;
info_ptr->valid &= ~PNG_INFO_iCCP; info_ptr->valid &= ~PNG_INFO_iCCP;
} }
#endif #endif
#if defined(PNG_sPLT_SUPPORTED) #if defined(PNG_sPLT_SUPPORTED)
/* free a given sPLT entry, or (if num == -1) all sPLT entries */ /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_SPLT) if (mask & PNG_FREE_SPLT)
#endif #endif
{ {
if (num != -1) if (num != -1)
{ {
if (info_ptr->splt_palettes) if (info_ptr->splt_palettes)
@ -481,7 +486,7 @@ if (mask & PNG_FREE_SPLT)
} }
info_ptr->valid &= ~PNG_INFO_sPLT; info_ptr->valid &= ~PNG_INFO_sPLT;
} }
} }
#endif #endif
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
@ -492,11 +497,11 @@ if (mask & PNG_FREE_SPLT)
} }
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_UNKN) if (mask & PNG_FREE_UNKN)
#endif #endif
{ {
if (num != -1) if (num != -1)
{ {
if (info_ptr->unknown_chunks) if (info_ptr->unknown_chunks)
@ -519,33 +524,33 @@ if (mask & PNG_FREE_UNKN)
info_ptr->unknown_chunks_num = 0; info_ptr->unknown_chunks_num = 0;
} }
} }
} }
#endif #endif
#if defined(PNG_hIST_SUPPORTED) #if defined(PNG_hIST_SUPPORTED)
/* free any hIST entry */ /* Free any hIST entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_HIST) & info_ptr->free_me) if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
#else #else
if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
#endif #endif
{ {
png_free(png_ptr, info_ptr->hist); png_free(png_ptr, info_ptr->hist);
info_ptr->hist = NULL; info_ptr->hist = NULL;
info_ptr->valid &= ~PNG_INFO_hIST; info_ptr->valid &= ~PNG_INFO_hIST;
#ifndef PNG_FREE_ME_SUPPORTED #ifndef PNG_FREE_ME_SUPPORTED
png_ptr->flags &= ~PNG_FLAG_FREE_HIST; png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
#endif #endif
} }
#endif #endif
/* free any PLTE entry that was internally allocated */ /* Free any PLTE entry that was internally allocated */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
#else #else
if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
#endif #endif
{ {
png_zfree(png_ptr, info_ptr->palette); png_zfree(png_ptr, info_ptr->palette);
info_ptr->palette = NULL; info_ptr->palette = NULL;
info_ptr->valid &= ~PNG_INFO_PLTE; info_ptr->valid &= ~PNG_INFO_PLTE;
@ -553,16 +558,16 @@ if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
#endif #endif
info_ptr->num_palette = 0; info_ptr->num_palette = 0;
} }
#if defined(PNG_INFO_IMAGE_SUPPORTED) #if defined(PNG_INFO_IMAGE_SUPPORTED)
/* free any image bits attached to the info structure */ /* Free any image bits attached to the info structure */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_ROWS) if (mask & PNG_FREE_ROWS)
#endif #endif
{ {
if (info_ptr->row_pointers) if (info_ptr->row_pointers)
{ {
int row; int row;
@ -575,7 +580,7 @@ if (mask & PNG_FREE_ROWS)
info_ptr->row_pointers=NULL; info_ptr->row_pointers=NULL;
} }
info_ptr->valid &= ~PNG_INFO_IDAT; info_ptr->valid &= ~PNG_INFO_IDAT;
} }
#endif #endif
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
@ -617,7 +622,8 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
png_voidp PNGAPI png_voidp PNGAPI
png_get_io_ptr(png_structp png_ptr) png_get_io_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
return (png_ptr->io_ptr); return (png_ptr->io_ptr);
} }
@ -633,7 +639,8 @@ void PNGAPI
png_init_io(png_structp png_ptr, png_FILE_p fp) png_init_io(png_structp png_ptr, png_FILE_p fp)
{ {
png_debug(1, "in png_init_io"); png_debug(1, "in png_init_io");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->io_ptr = (png_voidp)fp; png_ptr->io_ptr = (png_voidp)fp;
} }
#endif #endif
@ -649,7 +656,8 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
{"Jan", "Feb", "Mar", "Apr", "May", "Jun", {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
if (png_ptr->time_buffer == NULL) if (png_ptr->time_buffer == NULL)
{ {
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
@ -693,9 +701,9 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
png_charp PNGAPI png_charp PNGAPI
png_get_copyright(png_structp png_ptr) png_get_copyright(png_structp png_ptr)
{ {
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) "\n libpng version 1.2.37rc01 - May 19, 2009\n\ return ((png_charp) "\n libpng version 1.2.37beta03 - May 20, 2009\n\
Copyright (c) 1998-2008 Glenn Randers-Pehrson\n\ Copyright (c) 1998-2009 Glenn Randers-Pehrson\n\
Copyright (c) 1996-1997 Andreas Dilger\n\ Copyright (c) 1996-1997 Andreas Dilger\n\
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
} }
@ -712,7 +720,7 @@ png_charp PNGAPI
png_get_libpng_ver(png_structp png_ptr) png_get_libpng_ver(png_structp png_ptr)
{ {
/* Version of *.c files used when building libpng */ /* Version of *.c files used when building libpng */
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) PNG_LIBPNG_VER_STRING); return ((png_charp) PNG_LIBPNG_VER_STRING);
} }
@ -720,7 +728,7 @@ png_charp PNGAPI
png_get_header_ver(png_structp png_ptr) png_get_header_ver(png_structp png_ptr)
{ {
/* Version of *.h files used when building libpng */ /* Version of *.h files used when building libpng */
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) PNG_LIBPNG_VER_STRING); return ((png_charp) PNG_LIBPNG_VER_STRING);
} }
@ -728,7 +736,7 @@ png_charp PNGAPI
png_get_header_version(png_structp png_ptr) png_get_header_version(png_structp png_ptr)
{ {
/* Returns longer string containing both version and date */ /* Returns longer string containing both version and date */
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) PNG_HEADER_VERSION_STRING return ((png_charp) PNG_HEADER_VERSION_STRING
#ifndef PNG_READ_SUPPORTED #ifndef PNG_READ_SUPPORTED
" (NO READ SUPPORT)" " (NO READ SUPPORT)"
@ -741,7 +749,7 @@ png_get_header_version(png_structp png_ptr)
int PNGAPI int PNGAPI
png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
{ {
/* check chunk_name and return "keep" value if it's on the list, else 0 */ /* Check chunk_name and return "keep" value if it's on the list, else 0 */
int i; int i;
png_bytep p; png_bytep p;
if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0) if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
@ -758,7 +766,8 @@ png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
int PNGAPI int PNGAPI
png_reset_zstream(png_structp png_ptr) png_reset_zstream(png_structp png_ptr)
{ {
if (png_ptr == NULL) return Z_STREAM_ERROR; if (png_ptr == NULL)
return Z_STREAM_ERROR;
return (inflateReset(&png_ptr->zstream)); return (inflateReset(&png_ptr->zstream));
} }
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
@ -774,11 +783,11 @@ png_access_version_number(void)
#if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) #if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED)
#if !defined(PNG_1_0_X) #if !defined(PNG_1_0_X)
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
int PNGAPI int PNGAPI
png_mmx_support(void) png_mmx_support(void)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return -1; return -1;
} }
#endif /* PNG_1_0_X */ #endif /* PNG_1_0_X */
@ -802,18 +811,18 @@ png_convert_size(size_t size)
#if !defined(PNG_NO_CHECK_cHRM) #if !defined(PNG_NO_CHECK_cHRM)
/* /*
Multiply two 32-bit numbers, V1 and V2, using 32-bit * Multiply two 32-bit numbers, V1 and V2, using 32-bit
arithmetic, to produce a 64 bit result in the HI/LO words. * arithmetic, to produce a 64 bit result in the HI/LO words.
*
A B * A B
x C D * x C D
------ * ------
AD || BD * AD || BD
AC || CB || 0 * AC || CB || 0
*
where A and B are the high and low 16-bit words of V1, * where A and B are the high and low 16-bit words of V1,
C and D are the 16-bit words of V2, AD is the product of * C and D are the 16-bit words of V2, AD is the product of
A and D, and X || Y is (X << 16) + Y. * A and D, and X || Y is (X << 16) + Y.
*/ */
void png_64bit_product (long v1, long v2, unsigned long *hi_product, void png_64bit_product (long v1, long v2, unsigned long *hi_product,
@ -839,6 +848,7 @@ void png_64bit_product (long v1, long v2, unsigned long *hi_product,
*hi_product = (unsigned long)hi; *hi_product = (unsigned long)hi;
*lo_product = (unsigned long)lo; *lo_product = (unsigned long)lo;
} }
int /* private */ int /* private */
png_check_cHRM_fixed(png_structp png_ptr, png_check_cHRM_fixed(png_structp png_ptr,
png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

53
png.h
View File

@ -1,6 +1,6 @@
/* png.h - header file for PNG reference library /* png.h - header file for PNG reference library
* *
* libpng version 1.2.37beta03 - May 19, 2009 * libpng version 1.2.37beta03 - May 20, 2009
* Copyright (c) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -8,7 +8,7 @@
* Authors and maintainers: * Authors and maintainers:
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.2.37beta03 - May 19, 2009: Glenn * libpng versions 0.97, January 1998, through 1.2.37beta03 - May 20, 2009: Glenn
* See also "Contributing Authors", below. * See also "Contributing Authors", below.
* *
* Note about libpng version numbers: * Note about libpng version numbers:
@ -169,65 +169,64 @@
* 1.0.30 10 10030 10.so.0.30[.0] * 1.0.30 10 10030 10.so.0.30[.0]
* 1.2.22 13 10222 12.so.0.22[.0] * 1.2.22 13 10222 12.so.0.22[.0]
* 1.2.23beta01-05 13 10223 12.so.0.23[.0] * 1.2.23beta01-05 13 10223 12.so.0.23[.0]
* 1.2.23beta03 13 10223 12.so.0.23[.0] * 1.2.23rc01 13 10223 12.so.0.23[.0]
* 1.2.23 13 10223 12.so.0.23[.0] * 1.2.23 13 10223 12.so.0.23[.0]
* 1.2.24beta01-02 13 10224 12.so.0.24[.0] * 1.2.24beta01-02 13 10224 12.so.0.24[.0]
* 1.2.24beta03 13 10224 12.so.0.24[.0] * 1.2.24rc01 13 10224 12.so.0.24[.0]
* 1.2.24 13 10224 12.so.0.24[.0] * 1.2.24 13 10224 12.so.0.24[.0]
* 1.2.25beta01-06 13 10225 12.so.0.25[.0] * 1.2.25beta01-06 13 10225 12.so.0.25[.0]
* 1.2.25beta03-02 13 10225 12.so.0.25[.0] * 1.2.25rc01-02 13 10225 12.so.0.25[.0]
* 1.0.31 10 10031 10.so.0.31[.0] * 1.0.31 10 10031 10.so.0.31[.0]
* 1.2.25 13 10225 12.so.0.25[.0] * 1.2.25 13 10225 12.so.0.25[.0]
* 1.2.26beta01-06 13 10226 12.so.0.26[.0] * 1.2.26beta01-06 13 10226 12.so.0.26[.0]
* 1.2.26beta03 13 10226 12.so.0.26[.0] * 1.2.26rc01 13 10226 12.so.0.26[.0]
* 1.2.26 13 10226 12.so.0.26[.0] * 1.2.26 13 10226 12.so.0.26[.0]
* 1.0.32 10 10032 10.so.0.32[.0] * 1.0.32 10 10032 10.so.0.32[.0]
* 1.2.27beta01-06 13 10227 12.so.0.27[.0] * 1.2.27beta01-06 13 10227 12.so.0.27[.0]
* 1.2.27beta03 13 10227 12.so.0.27[.0] * 1.2.27rc01 13 10227 12.so.0.27[.0]
* 1.0.33 10 10033 10.so.0.33[.0] * 1.0.33 10 10033 10.so.0.33[.0]
* 1.2.27 13 10227 12.so.0.27[.0] * 1.2.27 13 10227 12.so.0.27[.0]
* 1.0.34 10 10034 10.so.0.34[.0] * 1.0.34 10 10034 10.so.0.34[.0]
* 1.2.28 13 10228 12.so.0.28[.0] * 1.2.28 13 10228 12.so.0.28[.0]
* 1.2.29beta01-03 13 10229 12.so.0.29[.0] * 1.2.29beta01-03 13 10229 12.so.0.29[.0]
* 1.2.29beta03 13 10229 12.so.0.29[.0] * 1.2.29rc01 13 10229 12.so.0.29[.0]
* 1.0.35 10 10035 10.so.0.35[.0] * 1.0.35 10 10035 10.so.0.35[.0]
* 1.2.29 13 10229 12.so.0.29[.0] * 1.2.29 13 10229 12.so.0.29[.0]
* 1.0.37 10 10037 10.so.0.37[.0] * 1.0.37 10 10037 10.so.0.37[.0]
* 1.2.30beta01-04 13 10230 12.so.0.30[.0] * 1.2.30beta01-04 13 10230 12.so.0.30[.0]
* 1.0.38beta03-08 10 10038 10.so.0.38[.0] * 1.0.38rc01-08 10 10038 10.so.0.38[.0]
* 1.2.30beta03-08 13 10230 12.so.0.30[.0] * 1.2.30rc01-08 13 10230 12.so.0.30[.0]
* 1.0.38 10 10038 10.so.0.38[.0] * 1.0.38 10 10038 10.so.0.38[.0]
* 1.2.30 13 10230 12.so.0.30[.0] * 1.2.30 13 10230 12.so.0.30[.0]
* 1.0.39beta03-03 10 10039 10.so.0.39[.0] * 1.0.39rc01-03 10 10039 10.so.0.39[.0]
* 1.2.31beta03-03 13 10231 12.so.0.31[.0] * 1.2.31rc01-03 13 10231 12.so.0.31[.0]
* 1.0.39 10 10039 10.so.0.39[.0] * 1.0.39 10 10039 10.so.0.39[.0]
* 1.2.31 13 10231 12.so.0.31[.0] * 1.2.31 13 10231 12.so.0.31[.0]
* 1.2.32beta01-02 13 10232 12.so.0.32[.0] * 1.2.32beta01-02 13 10232 12.so.0.32[.0]
* 1.0.40beta03 10 10040 10.so.0.40[.0] * 1.0.40rc01 10 10040 10.so.0.40[.0]
* 1.2.32beta03 13 10232 12.so.0.32[.0] * 1.2.32rc01 13 10232 12.so.0.32[.0]
* 1.0.40 10 10040 10.so.0.40[.0] * 1.0.40 10 10040 10.so.0.40[.0]
* 1.2.32 13 10232 12.so.0.32[.0] * 1.2.32 13 10232 12.so.0.32[.0]
* 1.2.33beta01-02 13 10233 12.so.0.33[.0] * 1.2.33beta01-02 13 10233 12.so.0.33[.0]
* 1.2.33beta03-02 13 10233 12.so.0.33[.0] * 1.2.33rc01-02 13 10233 12.so.0.33[.0]
* 1.0.41beta03 10 10041 10.so.0.41[.0] * 1.0.41rc01 10 10041 10.so.0.41[.0]
* 1.2.33 13 10233 12.so.0.33[.0] * 1.2.33 13 10233 12.so.0.33[.0]
* 1.0.41 10 10041 10.so.0.41[.0] * 1.0.41 10 10041 10.so.0.41[.0]
* 1.2.34beta01-07 13 10234 12.so.0.34[.0] * 1.2.34beta01-07 13 10234 12.so.0.34[.0]
* 1.0.42beta03 10 10042 10.so.0.42[.0] * 1.0.42rc01 10 10042 10.so.0.42[.0]
* 1.2.34beta03 13 10234 12.so.0.34[.0] * 1.2.34rc01 13 10234 12.so.0.34[.0]
* 1.0.42 10 10042 10.so.0.42[.0] * 1.0.42 10 10042 10.so.0.42[.0]
* 1.2.34 13 10234 12.so.0.34[.0] * 1.2.34 13 10234 12.so.0.34[.0]
* 1.2.35beta01-03 13 10235 12.so.0.35[.0] * 1.2.35beta01-03 13 10235 12.so.0.35[.0]
* 1.0.43beta03-02 10 10043 10.so.0.43[.0] * 1.0.43rc01-02 10 10043 10.so.0.43[.0]
* 1.2.35beta03-02 13 10235 12.so.0.35[.0] * 1.2.35rc01-02 13 10235 12.so.0.35[.0]
* 1.0.43 10 10043 10.so.0.43[.0] * 1.0.43 10 10043 10.so.0.43[.0]
* 1.2.35 13 10235 12.so.0.35[.0] * 1.2.35 13 10235 12.so.0.35[.0]
* 1.2.36beta01-05 13 10236 12.so.0.36[.0] * 1.2.36beta01-05 13 10236 12.so.0.36[.0]
* 1.2.36beta03 13 10236 12.so.0.36[.0] * 1.2.36rc01 13 10236 12.so.0.36[.0]
* 1.0.44 10 10044 10.so.0.44[.0] * 1.0.44 10 10044 10.so.0.44[.0]
* 1.2.36 13 10236 12.so.0.36[.0] * 1.2.36 13 10236 12.so.0.36[.0]
* 1.2.37beta01-03 13 10237 12.so.0.37[.0] * 1.2.37beta01-03 13 10237 12.so.0.37[.0]
* 1.2.37beta03 13 10237 12.so.0.37[.0]
* *
* Henceforth the source version will match the shared-library major * Henceforth the source version will match the shared-library major
* and minor numbers; the shared-library major version number will be * and minor numbers; the shared-library major version number will be
@ -257,7 +256,7 @@
* If you modify libpng you may insert additional notices immediately following * If you modify libpng you may insert additional notices immediately following
* this sentence. * this sentence.
* *
* libpng versions 1.2.6, August 15, 2004, through 1.2.37beta03, May 19, 2009, are * libpng versions 1.2.6, August 15, 2004, through 1.2.37beta03, May 20, 2009, are
* Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are * Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are
* distributed according to the same disclaimer and license as libpng-1.2.5 * distributed according to the same disclaimer and license as libpng-1.2.5
* with the following individual added to the list of Contributing Authors: * with the following individual added to the list of Contributing Authors:
@ -369,7 +368,7 @@
* Y2K compliance in libpng: * Y2K compliance in libpng:
* ========================= * =========================
* *
* May 19, 2009 * May 20, 2009
* *
* Since the PNG Development group is an ad-hoc body, we can't make * Since the PNG Development group is an ad-hoc body, we can't make
* an official declaration. * an official declaration.
@ -433,7 +432,7 @@
/* 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 "1.2.37beta03" #define PNG_LIBPNG_VER_STRING "1.2.37beta03"
#define PNG_HEADER_VERSION_STRING \ #define PNG_HEADER_VERSION_STRING \
" libpng version 1.2.37beta03 - May 19, 2009\n" " libpng version 1.2.37beta03 - May 20, 2009\n"
#define PNG_LIBPNG_VER_SONUM 0 #define PNG_LIBPNG_VER_SONUM 0
#define PNG_LIBPNG_VER_DLLNUM 13 #define PNG_LIBPNG_VER_DLLNUM 13
@ -445,7 +444,7 @@
/* This should match the numeric part of the final component of /* This should match the numeric part of the final component of
* PNG_LIBPNG_VER_STRING, omitting any leading zero: */ * PNG_LIBPNG_VER_STRING, omitting any leading zero: */
#define PNG_LIBPNG_VER_BUILD 01 #define PNG_LIBPNG_VER_BUILD 03
/* Release Status */ /* Release Status */
#define PNG_LIBPNG_BUILD_ALPHA 1 #define PNG_LIBPNG_BUILD_ALPHA 1
@ -462,7 +461,7 @@
#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
PNG_LIBPNG_BUILD_PRIVATE */ PNG_LIBPNG_BUILD_PRIVATE */
#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_RC #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_BETA
/* Careful here. At one time, Guy wanted to use 082, but that would be octal. /* Careful here. At one time, Guy wanted to use 082, but that would be octal.
* We must not include leading zeros. * We must not include leading zeros.

2
pngconf.h
View File

@ -1,7 +1,7 @@
/* pngconf.h - machine configurable file for libpng /* pngconf.h - machine configurable file for libpng
* *
* libpng version 1.2.37rc01 - May 19, 2009 * libpng version 1.2.37beta03 - May 20, 2009
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

10
pngerror.c
View File

@ -1,7 +1,7 @@
/* pngerror.c - stub functions for i/o and memory allocation /* pngerror.c - stub functions for i/o and memory allocation
* *
* Last changed in libpng 1.2.36 [May 7, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -234,10 +234,12 @@ png_default_error(png_structp png_ptr, png_const_charp error_message)
fprintf(stderr, PNG_STRING_NEWLINE); fprintf(stderr, PNG_STRING_NEWLINE);
} }
else else
{
fprintf(stderr, "libpng error: %s, offset=%d", fprintf(stderr, "libpng error: %s, offset=%d",
error_message, offset); error_message, offset);
fprintf(stderr, PNG_STRING_NEWLINE); fprintf(stderr, PNG_STRING_NEWLINE);
} }
}
else else
#endif #endif
{ {
@ -263,7 +265,7 @@ png_default_error(png_structp png_ptr, png_const_charp error_message)
PNG_ABORT(); PNG_ABORT();
#endif #endif
#ifdef PNG_NO_CONSOLE_IO #ifdef PNG_NO_CONSOLE_IO
error_message = error_message; /* make compiler happy */ error_message = error_message; /* Make compiler happy */
#endif #endif
} }
@ -309,9 +311,9 @@ png_default_warning(png_structp png_ptr, png_const_charp warning_message)
fprintf(stderr, PNG_STRING_NEWLINE); fprintf(stderr, PNG_STRING_NEWLINE);
} }
#else #else
warning_message = warning_message; /* make compiler happy */ warning_message = warning_message; /* Make compiler happy */
#endif #endif
png_ptr = png_ptr; /* make compiler happy */ png_ptr = png_ptr; /* Make compiler happy */
} }
#endif /* PNG_NO_WARNINGS */ #endif /* PNG_NO_WARNINGS */

92
pngget.c
View File

@ -1,9 +1,9 @@
/* pngget.c - retrieval of values from info struct /* pngget.c - retrieval of values from info struct
* *
* Last changed in libpng 1.2.30 [August 15, 2008] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@ -17,6 +17,7 @@ png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->valid & flag); return(info_ptr->valid & flag);
else else
return(0); return(0);
} }
@ -26,6 +27,7 @@ png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->rowbytes); return(info_ptr->rowbytes);
else else
return(0); return(0);
} }
@ -36,20 +38,20 @@ png_get_rows(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->row_pointers); return(info_ptr->row_pointers);
else else
return(0); return(0);
} }
#endif #endif
#ifdef PNG_EASY_ACCESS_SUPPORTED #ifdef PNG_EASY_ACCESS_SUPPORTED
/* easy access to info, added in libpng-0.99 */ /* Easy access to info, added in libpng-0.99 */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_image_width(png_structp png_ptr, png_infop info_ptr) png_get_image_width(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->width; return info_ptr->width;
}
return (0); return (0);
} }
@ -57,9 +59,8 @@ png_uint_32 PNGAPI
png_get_image_height(png_structp png_ptr, png_infop info_ptr) png_get_image_height(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->height; return info_ptr->height;
}
return (0); return (0);
} }
@ -67,9 +68,8 @@ png_byte PNGAPI
png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->bit_depth; return info_ptr->bit_depth;
}
return (0); return (0);
} }
@ -77,9 +77,8 @@ png_byte PNGAPI
png_get_color_type(png_structp png_ptr, png_infop info_ptr) png_get_color_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->color_type; return info_ptr->color_type;
}
return (0); return (0);
} }
@ -87,9 +86,8 @@ png_byte PNGAPI
png_get_filter_type(png_structp png_ptr, png_infop info_ptr) png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->filter_type; return info_ptr->filter_type;
}
return (0); return (0);
} }
@ -97,9 +95,8 @@ png_byte PNGAPI
png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->interlace_type; return info_ptr->interlace_type;
}
return (0); return (0);
} }
@ -107,9 +104,8 @@ png_byte PNGAPI
png_get_compression_type(png_structp png_ptr, png_infop info_ptr) png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->compression_type; return info_ptr->compression_type;
}
return (0); return (0);
} }
@ -121,8 +117,10 @@ png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter"); png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");
if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER) if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0); return (0);
else return (info_ptr->x_pixels_per_unit); else return (info_ptr->x_pixels_per_unit);
} }
#else #else
@ -139,8 +137,10 @@ png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter"); png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");
if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER) if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0); return (0);
else return (info_ptr->y_pixels_per_unit); else return (info_ptr->y_pixels_per_unit);
} }
#else #else
@ -157,9 +157,11 @@ png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter"); png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER || if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
return (0); return (0);
else return (info_ptr->x_pixels_per_unit); else return (info_ptr->x_pixels_per_unit);
} }
#else #else
@ -174,6 +176,7 @@ png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_pHYs_SUPPORTED) #if defined(PNG_pHYs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
@ -195,11 +198,14 @@ png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0); return (0);
else return (info_ptr->x_offset); else return (info_ptr->x_offset);
} }
#else #else
@ -212,12 +218,15 @@ png_int_32 PNGAPI
png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0); return (0);
else return (info_ptr->y_offset); else return (info_ptr->y_offset);
} }
#else #else
@ -230,12 +239,15 @@ png_int_32 PNGAPI
png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0); return (0);
else return (info_ptr->x_offset); else return (info_ptr->x_offset);
} }
#else #else
@ -248,12 +260,15 @@ png_int_32 PNGAPI
png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0); return (0);
else return (info_ptr->y_offset); else return (info_ptr->y_offset);
} }
#else #else
@ -495,8 +510,9 @@ png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
png_debug1(1, "in %s retrieval function", "iCCP"); png_debug1(1, "in %s retrieval function", "iCCP");
*name = info_ptr->iccp_name; *name = info_ptr->iccp_name;
*profile = info_ptr->iccp_profile; *profile = info_ptr->iccp_profile;
/* compression_type is a dummy so the API won't have to change /* Compression_type is a dummy so the API won't have to change
if we introduce multiple compression types later. */ * if we introduce multiple compression types later.
*/
*proflen = (int)info_ptr->iccp_proflen; *proflen = (int)info_ptr->iccp_proflen;
*compression_type = (int)info_ptr->iccp_compression; *compression_type = (int)info_ptr->iccp_compression;
return (PNG_INFO_iCCP); return (PNG_INFO_iCCP);
@ -550,21 +566,28 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
*bit_depth = info_ptr->bit_depth; *bit_depth = info_ptr->bit_depth;
if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16) if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)
png_error(png_ptr, "Invalid bit depth"); png_error(png_ptr, "Invalid bit depth");
*color_type = info_ptr->color_type; *color_type = info_ptr->color_type;
if (info_ptr->color_type > 6) if (info_ptr->color_type > 6)
png_error(png_ptr, "Invalid color type"); png_error(png_ptr, "Invalid color type");
if (compression_type != NULL) if (compression_type != NULL)
*compression_type = info_ptr->compression_type; *compression_type = info_ptr->compression_type;
if (filter_type != NULL) if (filter_type != NULL)
*filter_type = info_ptr->filter_type; *filter_type = info_ptr->filter_type;
if (interlace_type != NULL) if (interlace_type != NULL)
*interlace_type = info_ptr->interlace_type; *interlace_type = info_ptr->interlace_type;
/* check for potential overflow of rowbytes */ /* Check for potential overflow of rowbytes */
if (*width == 0 || *width > PNG_UINT_31_MAX) if (*width == 0 || *width > PNG_UINT_31_MAX)
png_error(png_ptr, "Invalid image width"); png_error(png_ptr, "Invalid image width");
if (*height == 0 || *height > PNG_UINT_31_MAX) if (*height == 0 || *height > PNG_UINT_31_MAX)
png_error(png_ptr, "Invalid image height"); png_error(png_ptr, "Invalid image height");
if (info_ptr->width > (PNG_UINT_32_MAX if (info_ptr->width > (PNG_UINT_32_MAX
>> 3) /* 8-byte RGBA pixels */ >> 3) /* 8-byte RGBA pixels */
- 64 /* bigrowbuf hack */ - 64 /* bigrowbuf hack */
@ -575,6 +598,7 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
png_warning(png_ptr, png_warning(png_ptr,
"Width too large for libpng to process image data."); "Width too large for libpng to process image data.");
} }
return (1); return (1);
} }
return (0); return (0);
@ -669,16 +693,19 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
(info_ptr->valid & PNG_INFO_pHYs)) (info_ptr->valid & PNG_INFO_pHYs))
{ {
png_debug1(1, "in %s retrieval function", "pHYs"); png_debug1(1, "in %s retrieval function", "pHYs");
if (res_x != NULL) if (res_x != NULL)
{ {
*res_x = info_ptr->x_pixels_per_unit; *res_x = info_ptr->x_pixels_per_unit;
retval |= PNG_INFO_pHYs; retval |= PNG_INFO_pHYs;
} }
if (res_y != NULL) if (res_y != NULL)
{ {
*res_y = info_ptr->y_pixels_per_unit; *res_y = info_ptr->y_pixels_per_unit;
retval |= PNG_INFO_pHYs; retval |= PNG_INFO_pHYs;
} }
if (unit_type != NULL) if (unit_type != NULL)
{ {
*unit_type = (int)info_ptr->phys_unit_type; *unit_type = (int)info_ptr->phys_unit_type;
@ -730,10 +757,13 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
png_debug1(1, "in %s retrieval function", png_debug1(1, "in %s retrieval function",
(png_ptr->chunk_name[0] == '\0' ? "text" (png_ptr->chunk_name[0] == '\0' ? "text"
: (png_const_charp)png_ptr->chunk_name)); : (png_const_charp)png_ptr->chunk_name));
if (text_ptr != NULL) if (text_ptr != NULL)
*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 ((png_uint_32)info_ptr->num_text); return ((png_uint_32)info_ptr->num_text);
} }
if (num_text != NULL) if (num_text != NULL)
@ -773,6 +803,7 @@ png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
*trans = info_ptr->trans; *trans = info_ptr->trans;
retval |= PNG_INFO_tRNS; retval |= PNG_INFO_tRNS;
} }
if (trans_values != NULL) if (trans_values != NULL)
*trans_values = &(info_ptr->trans_values); *trans_values = &(info_ptr->trans_values);
} }
@ -783,6 +814,7 @@ png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
*trans_values = &(info_ptr->trans_values); *trans_values = &(info_ptr->trans_values);
retval |= PNG_INFO_tRNS; retval |= PNG_INFO_tRNS;
} }
if (trans != NULL) if (trans != NULL)
*trans = NULL; *trans = NULL;
} }
@ -836,47 +868,47 @@ png_get_compression_buffer_size(png_structp png_ptr)
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
#ifndef PNG_1_0_X #ifndef PNG_1_0_X
/* this function was added to libpng 1.2.0 and should exist by default */ /* This function was added to libpng 1.2.0 and should exist by default */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_asm_flags (png_structp png_ptr) png_get_asm_flags (png_structp png_ptr)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return (png_ptr? 0L: 0L); return (png_ptr? 0L: 0L);
} }
/* this function was added to libpng 1.2.0 and should exist by default */ /* This function was added to libpng 1.2.0 and should exist by default */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_asm_flagmask (int flag_select) png_get_asm_flagmask (int flag_select)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
flag_select=flag_select; flag_select=flag_select;
return 0L; return 0L;
} }
/* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_mmx_flagmask (int flag_select, int *compilerID) png_get_mmx_flagmask (int flag_select, int *compilerID)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
flag_select=flag_select; flag_select=flag_select;
*compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */
return 0L; return 0L;
} }
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
png_byte PNGAPI png_byte PNGAPI
png_get_mmx_bitdepth_threshold (png_structp png_ptr) png_get_mmx_bitdepth_threshold (png_structp png_ptr)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return (png_ptr? 0: 0); return (png_ptr? 0: 0);
} }
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_mmx_rowbytes_threshold (png_structp png_ptr) png_get_mmx_rowbytes_threshold (png_structp png_ptr)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return (png_ptr? 0L: 0L); return (png_ptr? 0L: 0L);
} }
#endif /* ?PNG_1_0_X */ #endif /* ?PNG_1_0_X */

43
pngmem.c
View File

@ -1,9 +1,9 @@
/* pngmem.c - stub functions for memory allocation /* pngmem.c - stub functions for memory allocation
* *
* Last changed in libpng 1.2.30 [August 15, 2008] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
@ -20,7 +20,7 @@
/* Borland DOS special memory handler */ /* Borland DOS special memory handler */
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
/* if you change this, be sure to change the one in png.h also */ /* If you change this, be sure to change the one in png.h also */
/* Allocate memory for a png_struct. The malloc and memset can be replaced /* Allocate memory for a png_struct. The malloc and memset can be replaced
by a single call to calloc() if this is thought to improve performance. */ by a single call to calloc() if this is thought to improve performance. */
@ -154,7 +154,7 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
{ {
if (png_ptr->offset_table == NULL) if (png_ptr->offset_table == NULL)
{ {
/* try to see if we need to do any of this fancy stuff */ /* Try to see if we need to do any of this fancy stuff */
ret = farmalloc(size); ret = farmalloc(size);
if (ret == NULL || ((png_size_t)ret & 0xffff)) if (ret == NULL || ((png_size_t)ret & 0xffff))
{ {
@ -269,10 +269,10 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
return (ret); return (ret);
} }
/* free a pointer allocated by png_malloc(). In the default /* Free a pointer allocated by png_malloc(). In the default
configuration, png_ptr is not used, but is passed in case it * configuration, png_ptr is not used, but is passed in case it
is needed. If ptr is NULL, return without taking any action. */ * is needed. If ptr is NULL, return without taking any action.
*/
void PNGAPI void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr) png_free(png_structp png_ptr, png_voidp ptr)
{ {
@ -285,7 +285,8 @@ png_free(png_structp png_ptr, png_voidp ptr)
(*(png_ptr->free_fn))(png_ptr, ptr); (*(png_ptr->free_fn))(png_ptr, ptr);
return; return;
} }
else png_free_default(png_ptr, ptr); else
png_free_default(png_ptr, ptr);
} }
void PNGAPI void PNGAPI
@ -293,7 +294,8 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
{ {
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* PNG_USER_MEM_SUPPORTED */
if (png_ptr == NULL || ptr == NULL) return; if (png_ptr == NULL || ptr == NULL)
return;
if (png_ptr->offset_table != NULL) if (png_ptr->offset_table != NULL)
{ {
@ -420,10 +422,11 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
} }
/* Allocate memory. For reasonable files, size should never exceed /* Allocate memory. For reasonable files, size should never exceed
64K. However, zlib may allocate more then 64K if you don't tell * 64K. However, zlib may allocate more then 64K if you don't tell
it not to. See zconf.h and png.h for more information. zlib does * it not to. See zconf.h and png.h for more information. zlib does
need to allocate exactly 64K, so whatever you call here must * need to allocate exactly 64K, so whatever you call here must
have the ability to do that. */ * have the ability to do that.
*/
png_voidp PNGAPI png_voidp PNGAPI
@ -494,7 +497,8 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
} }
/* Free a pointer allocated by png_malloc(). If ptr is NULL, return /* Free a pointer allocated by png_malloc(). If ptr is NULL, return
without taking any action. */ * without taking any action.
*/
void PNGAPI void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr) png_free(png_structp png_ptr, png_voidp ptr)
{ {
@ -507,7 +511,8 @@ png_free(png_structp png_ptr, png_voidp ptr)
(*(png_ptr->free_fn))(png_ptr, ptr); (*(png_ptr->free_fn))(png_ptr, ptr);
return; return;
} }
else png_free_default(png_ptr, ptr); else
png_free_default(png_ptr, ptr);
} }
void PNGAPI void PNGAPI
png_free_default(png_structp png_ptr, png_voidp ptr) png_free_default(png_structp png_ptr, png_voidp ptr)
@ -543,7 +548,8 @@ png_malloc_warn(png_structp png_ptr, png_uint_32 size)
{ {
png_voidp ptr; png_voidp ptr;
png_uint_32 save_flags; png_uint_32 save_flags;
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
save_flags = png_ptr->flags; save_flags = png_ptr->flags;
png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
@ -603,7 +609,8 @@ png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
png_voidp PNGAPI png_voidp PNGAPI
png_get_mem_ptr(png_structp png_ptr) png_get_mem_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
return ((png_voidp)png_ptr->mem_ptr); return ((png_voidp)png_ptr->mem_ptr);
} }
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* PNG_USER_MEM_SUPPORTED */

202
pngpread.c
View File

@ -1,7 +1,7 @@
/* pngpread.c - read a png file in push mode /* pngpread.c - read a png file in push mode
* *
* Last changed in libpng 1.2.37 [May 19, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -12,7 +12,7 @@
#include "png.h" #include "png.h"
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
/* push model modes */ /* Push model modes */
#define PNG_READ_SIG_MODE 0 #define PNG_READ_SIG_MODE 0
#define PNG_READ_CHUNK_MODE 1 #define PNG_READ_CHUNK_MODE 1
#define PNG_READ_IDAT_MODE 2 #define PNG_READ_IDAT_MODE 2
@ -27,7 +27,9 @@ void PNGAPI
png_process_data(png_structp png_ptr, png_infop info_ptr, png_process_data(png_structp png_ptr, png_infop info_ptr,
png_bytep buffer, png_size_t buffer_size) png_bytep buffer, png_size_t buffer_size)
{ {
if (png_ptr == NULL || info_ptr == NULL) return; if (png_ptr == NULL || info_ptr == NULL)
return;
png_push_restore_buffer(png_ptr, buffer, buffer_size); png_push_restore_buffer(png_ptr, buffer, buffer_size);
while (png_ptr->buffer_size) while (png_ptr->buffer_size)
@ -42,7 +44,9 @@ png_process_data(png_structp png_ptr, png_infop info_ptr,
void /* PRIVATE */ void /* PRIVATE */
png_process_some_data(png_structp png_ptr, png_infop info_ptr) png_process_some_data(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
switch (png_ptr->process_mode) switch (png_ptr->process_mode)
{ {
case PNG_READ_SIG_MODE: case PNG_READ_SIG_MODE:
@ -50,22 +54,26 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
png_push_read_sig(png_ptr, info_ptr); png_push_read_sig(png_ptr, info_ptr);
break; break;
} }
case PNG_READ_CHUNK_MODE: case PNG_READ_CHUNK_MODE:
{ {
png_push_read_chunk(png_ptr, info_ptr); png_push_read_chunk(png_ptr, info_ptr);
break; break;
} }
case PNG_READ_IDAT_MODE: case PNG_READ_IDAT_MODE:
{ {
png_push_read_IDAT(png_ptr); png_push_read_IDAT(png_ptr);
break; break;
} }
#if defined(PNG_READ_tEXt_SUPPORTED) #if defined(PNG_READ_tEXt_SUPPORTED)
case PNG_READ_tEXt_MODE: case PNG_READ_tEXt_MODE:
{ {
png_push_read_tEXt(png_ptr, info_ptr); png_push_read_tEXt(png_ptr, info_ptr);
break; break;
} }
#endif #endif
#if defined(PNG_READ_zTXt_SUPPORTED) #if defined(PNG_READ_zTXt_SUPPORTED)
case PNG_READ_zTXt_MODE: case PNG_READ_zTXt_MODE:
@ -73,6 +81,7 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
png_push_read_zTXt(png_ptr, info_ptr); png_push_read_zTXt(png_ptr, info_ptr);
break; break;
} }
#endif #endif
#if defined(PNG_READ_iTXt_SUPPORTED) #if defined(PNG_READ_iTXt_SUPPORTED)
case PNG_READ_iTXt_MODE: case PNG_READ_iTXt_MODE:
@ -80,12 +89,14 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
png_push_read_iTXt(png_ptr, info_ptr); png_push_read_iTXt(png_ptr, info_ptr);
break; break;
} }
#endif #endif
case PNG_SKIP_MODE: case PNG_SKIP_MODE:
{ {
png_push_crc_finish(png_ptr); png_push_crc_finish(png_ptr);
break; break;
} }
default: default:
{ {
png_ptr->buffer_size = 0; png_ptr->buffer_size = 0;
@ -224,13 +235,16 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr->push_length != 13) if (png_ptr->push_length != 13)
png_error(png_ptr, "Invalid IHDR length"); png_error(png_ptr, "Invalid IHDR length");
if (png_ptr->push_length + 4 > png_ptr->buffer_size) if (png_ptr->push_length + 4 > png_ptr->buffer_size)
{ {
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
} }
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
{ {
if (png_ptr->push_length + 4 > png_ptr->buffer_size) if (png_ptr->push_length + 4 > png_ptr->buffer_size)
@ -238,11 +252,13 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length); png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
png_ptr->process_mode = PNG_READ_DONE_MODE; png_ptr->process_mode = PNG_READ_DONE_MODE;
png_push_have_end(png_ptr, info_ptr); png_push_have_end(png_ptr, info_ptr);
} }
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
{ {
@ -251,20 +267,26 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
png_ptr->mode |= PNG_HAVE_IDAT; png_ptr->mode |= PNG_HAVE_IDAT;
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
png_ptr->mode |= PNG_HAVE_PLTE; png_ptr->mode |= PNG_HAVE_PLTE;
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
{ {
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before IDAT"); png_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) !(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
} }
} }
#endif #endif
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
{ {
@ -275,14 +297,17 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
} }
png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
} }
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_IHDR)) if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before IDAT"); png_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) !(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
@ -305,6 +330,7 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_ptr->zstream.next_out = png_ptr->row_buf; png_ptr->zstream.next_out = png_ptr->row_buf;
return; return;
} }
#if defined(PNG_READ_gAMA_SUPPORTED) #if defined(PNG_READ_gAMA_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
{ {
@ -313,8 +339,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length); png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sBIT_SUPPORTED) #if defined(PNG_READ_sBIT_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
@ -324,8 +352,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length); png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_cHRM_SUPPORTED) #if defined(PNG_READ_cHRM_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
@ -335,8 +365,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
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) #if defined(PNG_READ_sRGB_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
@ -346,8 +378,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length); png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_iCCP_SUPPORTED) #if defined(PNG_READ_iCCP_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
@ -357,8 +391,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length); png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sPLT_SUPPORTED) #if defined(PNG_READ_sPLT_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
@ -368,8 +404,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length); png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #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))
@ -379,8 +417,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length); png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_bKGD_SUPPORTED) #if defined(PNG_READ_bKGD_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
@ -390,8 +430,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length); png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_hIST_SUPPORTED) #if defined(PNG_READ_hIST_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
@ -401,8 +443,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length); png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_pHYs_SUPPORTED) #if defined(PNG_READ_pHYs_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
@ -412,8 +456,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length); png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_oFFs_SUPPORTED) #if defined(PNG_READ_oFFs_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
@ -423,9 +469,11 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length); png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_pCAL_SUPPORTED) #if defined(PNG_READ_pCAL_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
{ {
@ -434,8 +482,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length); png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sCAL_SUPPORTED) #if defined(PNG_READ_sCAL_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
@ -445,8 +495,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length); png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_tIME_SUPPORTED) #if defined(PNG_READ_tIME_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
@ -456,8 +508,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length); png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #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))
@ -467,8 +521,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_zTXt_SUPPORTED) #if defined(PNG_READ_zTXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
@ -478,8 +534,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_iTXt_SUPPORTED) #if defined(PNG_READ_iTXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
@ -489,8 +547,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
else else
{ {
@ -565,7 +625,9 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
{ {
png_bytep ptr; png_bytep ptr;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
ptr = buffer; ptr = buffer;
if (png_ptr->save_buffer_size) if (png_ptr->save_buffer_size)
{ {
@ -589,6 +651,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
if (length < png_ptr->current_buffer_size) if (length < png_ptr->current_buffer_size)
save_size = length; save_size = length;
else else
save_size = png_ptr->current_buffer_size; save_size = png_ptr->current_buffer_size;
@ -629,6 +692,7 @@ png_push_save_buffer(png_structp png_ptr)
{ {
png_error(png_ptr, "Potential overflow of save_buffer"); png_error(png_ptr, "Potential overflow of save_buffer");
} }
new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
old_buffer = png_ptr->save_buffer; old_buffer = png_ptr->save_buffer;
png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr, png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
@ -697,7 +761,8 @@ png_push_read_IDAT(png_structp png_ptr)
if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size) if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
{ {
save_size = (png_size_t)png_ptr->idat_size; save_size = (png_size_t)png_ptr->idat_size;
/* check for overflow */
/* Check for overflow */
if ((png_uint_32)save_size != png_ptr->idat_size) if ((png_uint_32)save_size != png_ptr->idat_size)
png_error(png_ptr, "save_size overflowed in pngpread"); png_error(png_ptr, "save_size overflowed in pngpread");
} }
@ -705,8 +770,10 @@ png_push_read_IDAT(png_structp png_ptr)
save_size = png_ptr->save_buffer_size; save_size = png_ptr->save_buffer_size;
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
png_ptr->idat_size -= save_size; png_ptr->idat_size -= save_size;
png_ptr->buffer_size -= save_size; png_ptr->buffer_size -= save_size;
png_ptr->save_buffer_size -= save_size; png_ptr->save_buffer_size -= save_size;
@ -719,7 +786,8 @@ png_push_read_IDAT(png_structp png_ptr)
if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size) if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
{ {
save_size = (png_size_t)png_ptr->idat_size; save_size = (png_size_t)png_ptr->idat_size;
/* check for overflow */
/* Check for overflow */
if ((png_uint_32)save_size != png_ptr->idat_size) if ((png_uint_32)save_size != png_ptr->idat_size)
png_error(png_ptr, "save_size overflowed in pngpread"); png_error(png_ptr, "save_size overflowed in pngpread");
} }
@ -769,6 +837,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
{ {
if (png_ptr->zstream.avail_in) if (png_ptr->zstream.avail_in)
png_error(png_ptr, "Extra compressed data"); png_error(png_ptr, "Extra compressed data");
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
png_push_process_row(png_ptr); png_push_process_row(png_ptr);
@ -780,6 +849,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
} }
else if (ret == Z_BUF_ERROR) else if (ret == Z_BUF_ERROR)
break; break;
else else
png_error(png_ptr, "Decompression Error"); png_error(png_ptr, "Decompression Error");
} }
@ -801,6 +871,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
png_ptr->zstream.next_out = png_ptr->row_buf; png_ptr->zstream.next_out = png_ptr->row_buf;
} }
else else
break; break;
} }
@ -829,7 +900,7 @@ png_push_process_row(png_structp png_ptr)
png_do_read_transformations(png_ptr); png_do_read_transformations(png_ptr);
#if defined(PNG_READ_INTERLACING_SUPPORTED) #if defined(PNG_READ_INTERLACING_SUPPORTED)
/* blow up interlaced rows to full size */ /* Blow up interlaced rows to full size */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
@ -847,9 +918,10 @@ png_push_process_row(png_structp png_ptr)
for (i = 0; i < 8 && png_ptr->pass == 0; i++) for (i = 0; i < 8 && png_ptr->pass == 0; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */ png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
} }
if (png_ptr->pass == 2) /* pass 1 might be empty */
if (png_ptr->pass == 2) /* Pass 1 might be empty */
{ {
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
@ -857,6 +929,7 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
if (png_ptr->pass == 4 && png_ptr->height <= 4) if (png_ptr->pass == 4 && png_ptr->height <= 4)
{ {
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
@ -865,13 +938,16 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
if (png_ptr->pass == 6 && png_ptr->height <= 4) if (png_ptr->pass == 6 && png_ptr->height <= 4)
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
break; break;
} }
case 1: case 1:
{ {
int i; int i;
@ -880,7 +956,8 @@ png_push_process_row(png_structp png_ptr)
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 2) /* skip top 4 generated rows */
if (png_ptr->pass == 2) /* Skip top 4 generated rows */
{ {
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
@ -888,22 +965,27 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
break; break;
} }
case 2: case 2:
{ {
int i; int i;
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 4) /* pass 3 might be empty */
if (png_ptr->pass == 4) /* Pass 3 might be empty */
{ {
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
@ -911,17 +993,21 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
break; break;
} }
case 3: case 3:
{ {
int i; int i;
for (i = 0; i < 4 && png_ptr->pass == 3; i++) for (i = 0; i < 4 && png_ptr->pass == 3; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 4) /* skip top two generated rows */
if (png_ptr->pass == 4) /* Skip top two generated rows */
{ {
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
@ -929,49 +1015,61 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
break; break;
} }
case 4: case 4:
{ {
int i; int i;
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 6) /* pass 5 might be empty */
if (png_ptr->pass == 6) /* Pass 5 might be empty */
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
break; break;
} }
case 5: case 5:
{ {
int i; int i;
for (i = 0; i < 2 && png_ptr->pass == 5; i++) for (i = 0; i < 2 && png_ptr->pass == 5; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 6) /* skip top generated row */
if (png_ptr->pass == 6) /* Skip top generated row */
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
break; break;
} }
case 6: case 6:
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
if (png_ptr->pass != 6) if (png_ptr->pass != 6)
break; break;
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
@ -989,18 +1087,18 @@ void /* PRIVATE */
png_read_push_finish_row(png_structp png_ptr) png_read_push_finish_row(png_structp png_ptr)
{ {
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST 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 */
PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
/* Height of interlace block. This is not currently used - if you need /* Height of interlace block. This is not currently used - if you need
@ -1013,7 +1111,7 @@ png_read_push_finish_row(png_structp png_ptr)
if (png_ptr->row_number < png_ptr->num_rows) if (png_ptr->row_number < png_ptr->num_rows)
return; return;
#ifdef PNG_READ_INTERLACING_SUPPORTED #if defined(PNG_READ_INTERLACING_SUPPORTED)
if (png_ptr->interlaced) if (png_ptr->interlaced)
{ {
png_ptr->row_number = 0; png_ptr->row_number = 0;
@ -1029,6 +1127,7 @@ png_read_push_finish_row(png_structp png_ptr)
if (png_ptr->pass > 7) if (png_ptr->pass > 7)
png_ptr->pass--; png_ptr->pass--;
if (png_ptr->pass >= 7) if (png_ptr->pass >= 7)
break; break;
@ -1061,7 +1160,7 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
png_error(png_ptr, "Out of place tEXt"); png_error(png_ptr, "Out of place tEXt");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
@ -1093,8 +1192,10 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
if (png_ptr->buffer_size < png_ptr->current_text_left) if (png_ptr->buffer_size < png_ptr->current_text_left)
text_size = png_ptr->buffer_size; text_size = png_ptr->buffer_size;
else else
text_size = png_ptr->current_text_left; text_size = png_ptr->current_text_left;
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size; png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size; png_ptr->current_text_ptr += text_size;
@ -1122,7 +1223,7 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
key = png_ptr->current_text; key = png_ptr->current_text;
for (text = key; *text; text++) for (text = key; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
if (text < key + png_ptr->current_text_size) if (text < key + png_ptr->current_text_size)
text++; text++;
@ -1157,7 +1258,7 @@ png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
png_error(png_ptr, "Out of place zTXt"); png_error(png_ptr, "Out of place zTXt");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
@ -1191,8 +1292,10 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
text_size = png_ptr->buffer_size; text_size = png_ptr->buffer_size;
else else
text_size = png_ptr->current_text_left; text_size = png_ptr->current_text_left;
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size; png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size; png_ptr->current_text_ptr += text_size;
@ -1216,7 +1319,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
key = png_ptr->current_text; key = png_ptr->current_text;
for (text = key; *text; text++) for (text = key; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
/* zTXt can't have zero text */ /* zTXt can't have zero text */
if (text >= key + png_ptr->current_text_size) if (text >= key + png_ptr->current_text_size)
@ -1228,7 +1331,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
text++; text++;
if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */ if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */
{ {
png_ptr->current_text = NULL; png_ptr->current_text = NULL;
png_free(png_ptr, key); png_free(png_ptr, key);
@ -1267,11 +1370,15 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
text = (png_charp)png_malloc(png_ptr, text = (png_charp)png_malloc(png_ptr,
(png_uint_32)(png_ptr->zbuf_size (png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + key_size + 1)); - png_ptr->zstream.avail_out + key_size + 1));
png_memcpy(text + key_size, png_ptr->zbuf, png_memcpy(text + key_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
png_memcpy(text, key, key_size); png_memcpy(text, key, key_size);
text_size = key_size + png_ptr->zbuf_size - text_size = key_size + png_ptr->zbuf_size -
png_ptr->zstream.avail_out; png_ptr->zstream.avail_out;
*(text + text_size) = '\0'; *(text + text_size) = '\0';
} }
else else
@ -1282,10 +1389,13 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
text = (png_charp)png_malloc(png_ptr, text_size + text = (png_charp)png_malloc(png_ptr, text_size +
(png_uint_32)(png_ptr->zbuf_size (png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + 1)); - png_ptr->zstream.avail_out + 1));
png_memcpy(text, tmp, text_size); png_memcpy(text, tmp, text_size);
png_free(png_ptr, tmp); png_free(png_ptr, tmp);
png_memcpy(text + text_size, png_ptr->zbuf, png_memcpy(text + text_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
*(text + text_size) = '\0'; *(text + text_size) = '\0';
} }
@ -1349,7 +1459,7 @@ png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
png_error(png_ptr, "Out of place iTXt"); png_error(png_ptr, "Out of place iTXt");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
@ -1382,8 +1492,10 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
if (png_ptr->buffer_size < png_ptr->current_text_left) if (png_ptr->buffer_size < png_ptr->current_text_left)
text_size = png_ptr->buffer_size; text_size = png_ptr->buffer_size;
else else
text_size = png_ptr->current_text_left; text_size = png_ptr->current_text_left;
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size; png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size; png_ptr->current_text_ptr += text_size;
@ -1414,23 +1526,25 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
key = png_ptr->current_text; key = png_ptr->current_text;
for (lang = key; *lang; lang++) for (lang = key; *lang; lang++)
/* empty loop */ ; /* Empty loop */ ;
if (lang < key + png_ptr->current_text_size - 3) if (lang < key + png_ptr->current_text_size - 3)
lang++; lang++;
comp_flag = *lang++; comp_flag = *lang++;
lang++; /* skip comp_type, always zero */ lang++; /* Skip comp_type, always zero */
for (lang_key = lang; *lang_key; lang_key++) for (lang_key = lang; *lang_key; lang_key++)
/* empty loop */ ; /* Empty loop */ ;
lang_key++; /* skip NUL separator */
lang_key++; /* Skip NUL separator */
text=lang_key; text=lang_key;
if (lang_key < key + png_ptr->current_text_size - 1) if (lang_key < key + png_ptr->current_text_size - 1)
{ {
for (; *text; text++) for (; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
} }
if (text < key + png_ptr->current_text_size) if (text < key + png_ptr->current_text_size)
@ -1438,6 +1552,7 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
text_ptr = (png_textp)png_malloc(png_ptr, text_ptr = (png_textp)png_malloc(png_ptr,
(png_uint_32)png_sizeof(png_text)); (png_uint_32)png_sizeof(png_text));
text_ptr->compression = comp_flag + 2; text_ptr->compression = comp_flag + 2;
text_ptr->key = key; text_ptr->key = key;
text_ptr->lang = lang; text_ptr->lang = lang;
@ -1479,7 +1594,7 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
#endif #endif
png_chunk_error(png_ptr, "unknown critical chunk"); png_chunk_error(png_ptr, "unknown critical chunk");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
@ -1500,23 +1615,28 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
= '\0'; = '\0';
png_ptr->unknown_chunk.size = (png_size_t)length; png_ptr->unknown_chunk.size = (png_size_t)length;
if (length == 0) if (length == 0)
png_ptr->unknown_chunk.data = NULL; png_ptr->unknown_chunk.data = NULL;
else else
{ {
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
(png_uint_32)length); (png_uint_32)length);
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
} }
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
if (png_ptr->read_user_chunk_fn != NULL) if (png_ptr->read_user_chunk_fn != NULL)
{ {
/* callback to user unknown chunk handler */ /* Callback to user unknown chunk handler */
int ret; int ret;
ret = (*(png_ptr->read_user_chunk_fn)) ret = (*(png_ptr->read_user_chunk_fn))
(png_ptr, &png_ptr->unknown_chunk); (png_ptr, &png_ptr->unknown_chunk);
if (ret < 0) if (ret < 0)
png_chunk_error(png_ptr, "error in user chunk"); png_chunk_error(png_ptr, "error in user chunk");
if (ret == 0) if (ret == 0)
{ {
if (!(png_ptr->chunk_name[0] & 0x20)) if (!(png_ptr->chunk_name[0] & 0x20))
@ -1527,12 +1647,14 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
&png_ptr->unknown_chunk, 1); &png_ptr->unknown_chunk, 1);
} }
} }
else else
#endif #endif
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
png_free(png_ptr, png_ptr->unknown_chunk.data); png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr->unknown_chunk.data = NULL; png_ptr->unknown_chunk.data = NULL;
} }
else else
#endif #endif
skip=length; skip=length;
@ -1569,7 +1691,9 @@ png_progressive_combine_row (png_structp png_ptr,
PNG_CONST int FARDATA png_pass_dsp_mask[7] = PNG_CONST int FARDATA png_pass_dsp_mask[7] =
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
#endif #endif
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
} }
@ -1579,7 +1703,9 @@ png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
png_progressive_end_ptr end_fn) png_progressive_end_ptr end_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->info_fn = info_fn; png_ptr->info_fn = info_fn;
png_ptr->row_fn = row_fn; png_ptr->row_fn = row_fn;
png_ptr->end_fn = end_fn; png_ptr->end_fn = end_fn;
@ -1590,7 +1716,9 @@ png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
png_voidp PNGAPI png_voidp PNGAPI
png_get_progressive_ptr(png_structp png_ptr) png_get_progressive_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
return png_ptr->io_ptr; return png_ptr->io_ptr;
} }
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

77
pngread.c
View File

@ -1,7 +1,7 @@
/* pngread.c - read a PNG file /* pngread.c - read a PNG file
* *
* Last changed in libpng 1.2.35 [February 14, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -57,7 +57,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
if (png_ptr == NULL) if (png_ptr == NULL)
return (NULL); return (NULL);
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
@ -137,7 +137,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
} }
} }
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@ -266,7 +266,7 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
png_debug(1, "in png_read_init_3"); png_debug(1, "in png_read_init_3");
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* save jump buffer and error functions */ /* Save jump buffer and error functions */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
#endif #endif
@ -277,21 +277,21 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
png_ptr = *ptr_ptr; png_ptr = *ptr_ptr;
} }
/* reset all variables to 0 */ /* Reset all variables to 0 */
png_memset(png_ptr, 0, png_sizeof(png_struct)); png_memset(png_ptr, 0, png_sizeof(png_struct));
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* restore jump buffer */ /* Restore jump buffer */
png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
#endif #endif
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
#endif #endif
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@ -326,7 +326,8 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
void PNGAPI void PNGAPI
png_read_info(png_structp png_ptr, png_infop info_ptr) png_read_info(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr == NULL || info_ptr == NULL) return; if (png_ptr == NULL || info_ptr == NULL)
return;
png_debug(1, "in png_read_info"); png_debug(1, "in png_read_info");
/* If we haven't checked all of the PNG signature bytes, do so now. */ /* If we haven't checked all of the PNG signature bytes, do so now. */
if (png_ptr->sig_bytes < 8) if (png_ptr->sig_bytes < 8)
@ -529,12 +530,13 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
} }
#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
/* optional call to update the users info_ptr structure */ /* Optional call to update the users info_ptr structure */
void PNGAPI void PNGAPI
png_read_update_info(png_structp png_ptr, png_infop info_ptr) png_read_update_info(png_structp png_ptr, png_infop info_ptr)
{ {
png_debug(1, "in png_read_update_info"); png_debug(1, "in png_read_update_info");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
else else
@ -553,7 +555,8 @@ void PNGAPI
png_start_read_image(png_structp png_ptr) png_start_read_image(png_structp png_ptr)
{ {
png_debug(1, "in png_start_read_image"); png_debug(1, "in png_start_read_image");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
} }
@ -570,14 +573,15 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
#endif #endif
int ret; int ret;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_debug2(1, "in png_read_row (row %lu, pass %d)", png_debug2(1, "in png_read_row (row %lu, pass %d)",
png_ptr->row_number, png_ptr->pass); png_ptr->row_number, png_ptr->pass);
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
if (png_ptr->row_number == 0 && png_ptr->pass == 0) if (png_ptr->row_number == 0 && png_ptr->pass == 0)
{ {
/* check for transforms that have been set but were defined out */ /* Check for transforms that have been set but were defined out */
#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
if (png_ptr->transformations & PNG_INVERT_MONO) if (png_ptr->transformations & PNG_INVERT_MONO)
png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
@ -609,7 +613,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
} }
#if defined(PNG_READ_INTERLACING_SUPPORTED) #if defined(PNG_READ_INTERLACING_SUPPORTED)
/* if interlaced and we do not need a new row, combine row and return */ /* If interlaced and we do not need a new row, combine row and return */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
{ {
switch (png_ptr->pass) switch (png_ptr->pass)
@ -756,14 +760,14 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
png_do_read_transformations(png_ptr); png_do_read_transformations(png_ptr);
#if defined(PNG_READ_INTERLACING_SUPPORTED) #if defined(PNG_READ_INTERLACING_SUPPORTED)
/* blow up interlaced rows to full size */ /* Blow up interlaced rows to full size */
if (png_ptr->interlaced && if (png_ptr->interlaced &&
(png_ptr->transformations & PNG_INTERLACE)) (png_ptr->transformations & PNG_INTERLACE))
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
/* old interface (pre-1.0.9): /* Old interface (pre-1.0.9):
png_do_read_interlace(&(png_ptr->row_info), * png_do_read_interlace(&(png_ptr->row_info),
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); * png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
*/ */
png_do_read_interlace(png_ptr); png_do_read_interlace(png_ptr);
@ -823,7 +827,8 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
png_bytepp dp; png_bytepp dp;
png_debug(1, "in png_read_rows"); png_debug(1, "in png_read_rows");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
rp = row; rp = row;
dp = display_row; dp = display_row;
if (rp != NULL && dp != NULL) if (rp != NULL && dp != NULL)
@ -872,7 +877,8 @@ png_read_image(png_structp png_ptr, png_bytepp image)
png_bytepp rp; png_bytepp rp;
png_debug(1, "in png_read_image"); png_debug(1, "in png_read_image");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
pass = png_set_interlace_handling(png_ptr); pass = png_set_interlace_handling(png_ptr);
@ -908,7 +914,8 @@ void PNGAPI
png_read_end(png_structp png_ptr, png_infop info_ptr) png_read_end(png_structp png_ptr, png_infop info_ptr)
{ {
png_debug(1, "in png_read_end"); png_debug(1, "in png_read_end");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
do do
@ -1075,7 +1082,7 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
} }
#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
/* free all memory used by the read */ /* Free all memory used by the read */
void PNGAPI void PNGAPI
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
png_infopp end_info_ptr_ptr) png_infopp end_info_ptr_ptr)
@ -1147,7 +1154,7 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
} }
} }
/* free all memory used by the read (old method) */ /* Free all memory used by the read (old method) */
void /* PRIVATE */ void /* PRIVATE */
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)
{ {
@ -1296,7 +1303,8 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
void PNGAPI void PNGAPI
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->read_row_fn = read_row_fn; png_ptr->read_row_fn = read_row_fn;
} }
@ -1310,9 +1318,10 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
{ {
int row; int row;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel from opacity to transparency /* Invert the alpha channel from opacity to transparency
*/ */
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
png_set_invert_alpha(png_ptr); png_set_invert_alpha(png_ptr);
@ -1328,7 +1337,7 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
/* -------------- image transformations start here ------------------- */ /* -------------- image transformations start here ------------------- */
#if defined(PNG_READ_16_TO_8_SUPPORTED) #if defined(PNG_READ_16_TO_8_SUPPORTED)
/* tell libpng to strip 16 bit/color files down to 8 bits per color /* Tell libpng to strip 16 bit/color files down to 8 bits per color.
*/ */
if (transforms & PNG_TRANSFORM_STRIP_16) if (transforms & PNG_TRANSFORM_STRIP_16)
png_set_strip_16(png_ptr); png_set_strip_16(png_ptr);
@ -1375,7 +1384,7 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
*/ */
#if defined(PNG_READ_INVERT_SUPPORTED) #if defined(PNG_READ_INVERT_SUPPORTED)
/* invert monochrome files to have 0 as white and 1 as black /* Invert monochrome files to have 0 as white and 1 as black
*/ */
if (transforms & PNG_TRANSFORM_INVERT_MONO) if (transforms & PNG_TRANSFORM_INVERT_MONO)
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
@ -1397,21 +1406,21 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
#endif #endif
#if defined(PNG_READ_BGR_SUPPORTED) #if defined(PNG_READ_BGR_SUPPORTED)
/* flip the RGB pixels to BGR (or RGBA to BGRA) /* Flip the RGB pixels to BGR (or RGBA to BGRA)
*/ */
if (transforms & PNG_TRANSFORM_BGR) if (transforms & PNG_TRANSFORM_BGR)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
#endif #endif
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
/* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)
*/ */
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
#endif #endif
#if defined(PNG_READ_SWAP_SUPPORTED) #if defined(PNG_READ_SWAP_SUPPORTED)
/* swap bytes of 16 bit files to least significant byte first /* Swap bytes of 16 bit files to least significant byte first
*/ */
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
png_set_swap(png_ptr); png_set_swap(png_ptr);
@ -1447,10 +1456,10 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
png_read_image(png_ptr, info_ptr->row_pointers); png_read_image(png_ptr, info_ptr->row_pointers);
info_ptr->valid |= PNG_INFO_IDAT; info_ptr->valid |= PNG_INFO_IDAT;
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */ /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
png_read_end(png_ptr, info_ptr); png_read_end(png_ptr, info_ptr);
transforms = transforms; /* quiet compiler warnings */ transforms = transforms; /* Quiet compiler warnings */
params = params; params = params;
} }

58
pngrio.c
View File

@ -1,7 +1,7 @@
/* pngrio.c - functions for data input /* pngrio.c - functions for data input
* *
* Last changed in libpng 1.2.36 [May 7, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -20,10 +20,11 @@
#if defined(PNG_READ_SUPPORTED) #if defined(PNG_READ_SUPPORTED)
/* Read the data from whatever input you are using. The default routine /* Read the data from whatever input you are using. The default routine
reads from a file pointer. Note that this routine sometimes gets called * reads from a file pointer. Note that this routine sometimes gets called
with very small lengths, so you should implement some kind of simple * with very small lengths, so you should implement some kind of simple
buffering if you are using unbuffered reads. This should never be asked * buffering if you are using unbuffered reads. This should never be asked
to read more then 64K on a 16 bit machine. */ * to read more then 64K on a 16 bit machine.
*/
void /* PRIVATE */ void /* PRIVATE */
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
@ -36,16 +37,18 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
/* This is the function that does the actual reading of data. If you are /* This is the function that does the actual reading of data. If you are
not reading from a standard C stream, you should create a replacement * not reading from a standard C stream, you should create a replacement
read_data function and use it at run time with png_set_read_fn(), rather * read_data function and use it at run time with png_set_read_fn(), rather
than changing the library. */ * than changing the library.
*/
#ifndef USE_FAR_KEYWORD #ifndef USE_FAR_KEYWORD
void PNGAPI void PNGAPI
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
png_size_t check; png_size_t check;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
/* fread() returns 0 on error, so it is OK to store this in a png_size_t /* fread() returns 0 on error, so it is OK to store this in a png_size_t
* instead of an int, which is what fread() actually returns. * instead of an int, which is what fread() actually returns.
*/ */
@ -61,7 +64,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_error(png_ptr, "Read Error"); png_error(png_ptr, "Read Error");
} }
#else #else
/* this is the model-independent version. Since the standard I/O library /* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy can't handle far buffers in the medium and small models, we have to copy
the data. the data.
*/ */
@ -76,7 +79,8 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_byte *n_data; png_byte *n_data;
png_FILE_p io_ptr; png_FILE_p io_ptr;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
/* Check if data really is near. If so, use usual code. */ /* Check if data really is near. If so, use usual code. */
n_data = (png_byte *)CVT_PTR_NOCHECK(data); n_data = (png_byte *)CVT_PTR_NOCHECK(data);
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
@ -121,25 +125,27 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
#endif #endif
/* This function allows the application to supply a new input function /* This function allows the application to supply a new input function
for libpng if standard C streams aren't being used. * for libpng if standard C streams aren't being used.
*
This function takes as its arguments: * This function takes as its arguments:
png_ptr - pointer to a png input data structure * png_ptr - pointer to a png input data structure
io_ptr - pointer to user supplied structure containing info about * io_ptr - pointer to user supplied structure containing info about
the input functions. May be NULL. * the input functions. May be NULL.
read_data_fn - pointer to a new input function that takes as its * read_data_fn - pointer to a new input function that takes as its
arguments a pointer to a png_struct, a pointer to * arguments a pointer to a png_struct, a pointer to
a location where input data can be stored, and a 32-bit * a location where input data can be stored, and a 32-bit
unsigned int that is the number of bytes to be read. * unsigned int that is the number of bytes to be read.
To exit and output any fatal error messages the new write * To exit and output any fatal error messages the new write
function should call png_error(png_ptr, "Error msg"). * function should call png_error(png_ptr, "Error msg").
May be NULL, in which case libpng's default function will * May be NULL, in which case libpng's default function will
be used. */ * be used.
*/
void PNGAPI void PNGAPI
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr read_data_fn) png_rw_ptr read_data_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->io_ptr = io_ptr; png_ptr->io_ptr = io_ptr;
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)

334
pngrtran.c
View File

@ -1,7 +1,7 @@
/* pngrtran.c - transforms the data in a row for PNG readers /* pngrtran.c - transforms the data in a row for PNG readers
* *
* Last changed in libpng 1.2.35 [February 14, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -23,24 +23,29 @@ png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
{ {
png_debug(1, "in png_set_crc_action"); png_debug(1, "in png_set_crc_action");
/* Tell libpng how we react to CRC errors in critical chunks */ /* Tell libpng how we react to CRC errors in critical chunks */
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
switch (crit_action) switch (crit_action)
{ {
case PNG_CRC_NO_CHANGE: /* leave setting as is */ case PNG_CRC_NO_CHANGE: /* Leave setting as is */
break; break;
case PNG_CRC_WARN_USE: /* warn/use data */
case PNG_CRC_WARN_USE: /* Warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE; png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
break; break;
case PNG_CRC_QUIET_USE: /* quiet/use data */
case PNG_CRC_QUIET_USE: /* Quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE | png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
PNG_FLAG_CRC_CRITICAL_IGNORE; PNG_FLAG_CRC_CRITICAL_IGNORE;
break; break;
case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */
case PNG_CRC_WARN_DISCARD: /* Not a valid action for critical data */
png_warning(png_ptr, png_warning(png_ptr,
"Can't discard critical data on CRC error."); "Can't discard critical data on CRC error.");
case PNG_CRC_ERROR_QUIT: /* error/quit */ case PNG_CRC_ERROR_QUIT: /* Error/quit */
case PNG_CRC_DEFAULT: case PNG_CRC_DEFAULT:
default: default:
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
@ -49,22 +54,27 @@ png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
switch (ancil_action) switch (ancil_action)
{ {
case PNG_CRC_NO_CHANGE: /* leave setting as is */ case PNG_CRC_NO_CHANGE: /* Leave setting as is */
break; break;
case PNG_CRC_WARN_USE: /* warn/use data */
case PNG_CRC_WARN_USE: /* Warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE; png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
break; break;
case PNG_CRC_QUIET_USE: /* quiet/use data */
case PNG_CRC_QUIET_USE: /* Quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE | png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
PNG_FLAG_CRC_ANCILLARY_NOWARN; PNG_FLAG_CRC_ANCILLARY_NOWARN;
break; break;
case PNG_CRC_ERROR_QUIT: /* error/quit */
case PNG_CRC_ERROR_QUIT: /* Error/quit */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN; png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
break; break;
case PNG_CRC_WARN_DISCARD: /* warn/discard data */
case PNG_CRC_WARN_DISCARD: /* Warn/discard data */
case PNG_CRC_DEFAULT: case PNG_CRC_DEFAULT:
default: default:
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
@ -74,14 +84,15 @@ png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
defined(PNG_FLOATING_POINT_SUPPORTED) defined(PNG_FLOATING_POINT_SUPPORTED)
/* handle alpha and tRNS via a background color */ /* Handle alpha and tRNS via a background color */
void PNGAPI void PNGAPI
png_set_background(png_structp png_ptr, png_set_background(png_structp png_ptr,
png_color_16p background_color, int background_gamma_code, png_color_16p background_color, int background_gamma_code,
int need_expand, double background_gamma) int need_expand, double background_gamma)
{ {
png_debug(1, "in png_set_background"); png_debug(1, "in png_set_background");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
{ {
png_warning(png_ptr, "Application must supply a known background gamma"); png_warning(png_ptr, "Application must supply a known background gamma");
@ -98,12 +109,13 @@ png_set_background(png_structp png_ptr,
#endif #endif
#if defined(PNG_READ_16_TO_8_SUPPORTED) #if defined(PNG_READ_16_TO_8_SUPPORTED)
/* strip 16 bit depth files to 8 bit depth */ /* Strip 16 bit depth files to 8 bit depth */
void PNGAPI void PNGAPI
png_set_strip_16(png_structp png_ptr) png_set_strip_16(png_structp png_ptr)
{ {
png_debug(1, "in png_set_strip_16"); png_debug(1, "in png_set_strip_16");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_16_TO_8; png_ptr->transformations |= PNG_16_TO_8;
} }
#endif #endif
@ -113,7 +125,8 @@ void PNGAPI
png_set_strip_alpha(png_structp png_ptr) png_set_strip_alpha(png_structp png_ptr)
{ {
png_debug(1, "in png_set_strip_alpha"); png_debug(1, "in png_set_strip_alpha");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
} }
#endif #endif
@ -143,7 +156,8 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
int full_dither) int full_dither)
{ {
png_debug(1, "in png_set_dither"); png_debug(1, "in png_set_dither");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_DITHER; png_ptr->transformations |= PNG_DITHER;
if (!full_dither) if (!full_dither)
@ -161,27 +175,29 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
if (histogram != NULL) if (histogram != NULL)
{ {
/* This is easy enough, just throw out the least used colors. /* This is easy enough, just throw out the least used colors.
Perhaps not the best solution, but good enough. */ * Perhaps not the best solution, but good enough.
*/
int i; int i;
/* initialize an array to sort colors */ /* Initialize an array to sort colors */
png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr, png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,
(png_uint_32)(num_palette * png_sizeof(png_byte))); (png_uint_32)(num_palette * png_sizeof(png_byte)));
/* initialize the dither_sort array */ /* Initialize the dither_sort array */
for (i = 0; i < num_palette; i++) for (i = 0; i < num_palette; i++)
png_ptr->dither_sort[i] = (png_byte)i; png_ptr->dither_sort[i] = (png_byte)i;
/* Find the least used palette entries by starting a /* Find the least used palette entries by starting a
bubble sort, and running it until we have sorted * bubble sort, and running it until we have sorted
out enough colors. Note that we don't care about * out enough colors. Note that we don't care about
sorting all the colors, just finding which are * sorting all the colors, just finding which are
least used. */ * least used.
*/
for (i = num_palette - 1; i >= maximum_colors; i--) for (i = num_palette - 1; i >= maximum_colors; i--)
{ {
int done; /* to stop early if the list is pre-sorted */ int done; /* To stop early if the list is pre-sorted */
int j; int j;
done = 1; done = 1;
@ -202,13 +218,14 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
break; break;
} }
/* swap the palette around, and set up a table, if necessary */ /* Swap the palette around, and set up a table, if necessary */
if (full_dither) if (full_dither)
{ {
int j = num_palette; int j = num_palette;
/* put all the useful colors within the max, but don't /* Put all the useful colors within the max, but don't
move the others */ * move the others.
*/
for (i = 0; i < maximum_colors; i++) for (i = 0; i < maximum_colors; i++)
{ {
if ((int)png_ptr->dither_sort[i] >= maximum_colors) if ((int)png_ptr->dither_sort[i] >= maximum_colors)
@ -224,11 +241,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
{ {
int j = num_palette; int j = num_palette;
/* move all the used colors inside the max limit, and /* Move all the used colors inside the max limit, and
develop a translation table */ * develop a translation table.
*/
for (i = 0; i < maximum_colors; i++) for (i = 0; i < maximum_colors; i++)
{ {
/* only move the colors we need to */ /* Only move the colors we need to */
if ((int)png_ptr->dither_sort[i] >= maximum_colors) if ((int)png_ptr->dither_sort[i] >= maximum_colors)
{ {
png_color tmp_color; png_color tmp_color;
@ -240,20 +258,20 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
tmp_color = palette[j]; tmp_color = palette[j];
palette[j] = palette[i]; palette[j] = palette[i];
palette[i] = tmp_color; palette[i] = tmp_color;
/* indicate where the color went */ /* Indicate where the color went */
png_ptr->dither_index[j] = (png_byte)i; png_ptr->dither_index[j] = (png_byte)i;
png_ptr->dither_index[i] = (png_byte)j; png_ptr->dither_index[i] = (png_byte)j;
} }
} }
/* find closest color for those colors we are not using */ /* Find closest color for those colors we are not using */
for (i = 0; i < num_palette; i++) for (i = 0; i < num_palette; i++)
{ {
if ((int)png_ptr->dither_index[i] >= maximum_colors) if ((int)png_ptr->dither_index[i] >= maximum_colors)
{ {
int min_d, k, min_k, d_index; int min_d, k, min_k, d_index;
/* find the closest color to one we threw out */ /* Find the closest color to one we threw out */
d_index = png_ptr->dither_index[i]; d_index = png_ptr->dither_index[i];
min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
for (k = 1, min_k = 0; k < maximum_colors; k++) for (k = 1, min_k = 0; k < maximum_colors; k++)
@ -268,7 +286,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
min_k = k; min_k = k;
} }
} }
/* point to closest color */ /* Point to closest color */
png_ptr->dither_index[i] = (png_byte)min_k; png_ptr->dither_index[i] = (png_byte)min_k;
} }
} }
@ -279,12 +297,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
else else
{ {
/* This is much harder to do simply (and quickly). Perhaps /* This is much harder to do simply (and quickly). Perhaps
we need to go through a median cut routine, but those * we need to go through a median cut routine, but those
don't always behave themselves with only a few colors * don't always behave themselves with only a few colors
as input. So we will just find the closest two colors, * as input. So we will just find the closest two colors,
and throw out one of them (chosen somewhat randomly). * and throw out one of them (chosen somewhat randomly).
[We don't understand this at all, so if someone wants to * [We don't understand this at all, so if someone wants to
work on improving it, be our guest - AED, GRP] * work on improving it, be our guest - AED, GRP]
*/ */
int i; int i;
int max_d; int max_d;
@ -294,13 +312,13 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
t = NULL; t = NULL;
/* initialize palette index arrays */ /* Initialize palette index arrays */
png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
(png_uint_32)(num_palette * png_sizeof(png_byte))); (png_uint_32)(num_palette * png_sizeof(png_byte)));
png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
(png_uint_32)(num_palette * png_sizeof(png_byte))); (png_uint_32)(num_palette * png_sizeof(png_byte)));
/* initialize the sort array */ /* Initialize the sort array */
for (i = 0; i < num_palette; i++) for (i = 0; i < num_palette; i++)
{ {
png_ptr->index_to_palette[i] = (png_byte)i; png_ptr->index_to_palette[i] = (png_byte)i;
@ -313,13 +331,13 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
num_new_palette = num_palette; num_new_palette = num_palette;
/* initial wild guess at how far apart the farthest pixel /* Initial wild guess at how far apart the farthest pixel
pair we will be eliminating will be. Larger * pair we will be eliminating will be. Larger
numbers mean more areas will be allocated, Smaller * numbers mean more areas will be allocated, Smaller
numbers run the risk of not saving enough data, and * numbers run the risk of not saving enough data, and
having to do this all over again. * having to do this all over again.
*
I have not done extensive checking on this number. * I have not done extensive checking on this number.
*/ */
max_d = 96; max_d = 96;
@ -523,7 +541,8 @@ void PNGAPI
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
{ {
png_debug(1, "in png_set_gamma"); png_debug(1, "in png_set_gamma");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) || if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
@ -542,7 +561,8 @@ void PNGAPI
png_set_expand(png_structp png_ptr) png_set_expand(png_structp png_ptr)
{ {
png_debug(1, "in png_set_expand"); png_debug(1, "in png_set_expand");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
} }
@ -569,7 +589,8 @@ void PNGAPI
png_set_palette_to_rgb(png_structp png_ptr) png_set_palette_to_rgb(png_structp png_ptr)
{ {
png_debug(1, "in png_set_palette_to_rgb"); png_debug(1, "in png_set_palette_to_rgb");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
} }
@ -580,7 +601,8 @@ void PNGAPI
png_set_expand_gray_1_2_4_to_8(png_structp png_ptr) png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
{ {
png_debug(1, "in png_set_expand_gray_1_2_4_to_8"); png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_EXPAND; png_ptr->transformations |= PNG_EXPAND;
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
} }
@ -593,7 +615,8 @@ void PNGAPI
png_set_gray_1_2_4_to_8(png_structp png_ptr) png_set_gray_1_2_4_to_8(png_structp png_ptr)
{ {
png_debug(1, "in png_set_gray_1_2_4_to_8"); png_debug(1, "in png_set_gray_1_2_4_to_8");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
} }
#endif #endif
@ -631,7 +654,8 @@ png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
{ {
int red_fixed = (int)((float)red*100000.0 + 0.5); int red_fixed = (int)((float)red*100000.0 + 0.5);
int green_fixed = (int)((float)green*100000.0 + 0.5); int green_fixed = (int)((float)green*100000.0 + 0.5);
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed); png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
} }
#endif #endif
@ -641,13 +665,16 @@ png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
png_fixed_point red, png_fixed_point green) png_fixed_point red, png_fixed_point green)
{ {
png_debug(1, "in png_set_rgb_to_gray"); png_debug(1, "in png_set_rgb_to_gray");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
switch(error_action) switch(error_action)
{ {
case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY; case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
break; break;
case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
break; break;
case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
} }
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
@ -694,7 +721,8 @@ png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
read_user_transform_fn) read_user_transform_fn)
{ {
png_debug(1, "in png_set_read_user_transform_fn"); png_debug(1, "in png_set_read_user_transform_fn");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
png_ptr->transformations |= PNG_USER_TRANSFORM; png_ptr->transformations |= PNG_USER_TRANSFORM;
png_ptr->read_user_transform_fn = read_user_transform_fn; png_ptr->read_user_transform_fn = read_user_transform_fn;
@ -727,8 +755,9 @@ png_init_read_transformations(png_structp png_ptr)
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
/* Detect gray background and attempt to enable optimization /* Detect gray background and attempt to enable optimization
* for gray --> RGB case */ * for gray --> RGB case
/* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or *
* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
* RGB_ALPHA (in which case need_expand is superfluous anyway), the * RGB_ALPHA (in which case need_expand is superfluous anyway), the
* background color might actually be gray yet not be flagged as such. * background color might actually be gray yet not be flagged as such.
* This is not a problem for the current code, which uses * This is not a problem for the current code, which uses
@ -755,7 +784,7 @@ png_init_read_transformations(png_structp png_ptr)
{ {
if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */ if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */
{ {
/* expand background and tRNS chunks */ /* Expand background and tRNS chunks */
switch (png_ptr->bit_depth) switch (png_ptr->bit_depth)
{ {
case 1: case 1:
@ -769,6 +798,7 @@ png_init_read_transformations(png_structp png_ptr)
= png_ptr->trans_values.blue = png_ptr->trans_values.gray; = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
} }
break; break;
case 2: case 2:
png_ptr->background.gray *= (png_uint_16)0x55; png_ptr->background.gray *= (png_uint_16)0x55;
png_ptr->background.red = png_ptr->background.green png_ptr->background.red = png_ptr->background.green
@ -780,6 +810,7 @@ png_init_read_transformations(png_structp png_ptr)
= png_ptr->trans_values.blue = png_ptr->trans_values.gray; = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
} }
break; break;
case 4: case 4:
png_ptr->background.gray *= (png_uint_16)0x11; png_ptr->background.gray *= (png_uint_16)0x11;
png_ptr->background.red = png_ptr->background.green png_ptr->background.red = png_ptr->background.green
@ -791,7 +822,9 @@ png_init_read_transformations(png_structp png_ptr)
= png_ptr->trans_values.blue = png_ptr->trans_values.gray; = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
} }
break; break;
case 8: case 8:
case 16: case 16:
png_ptr->background.red = png_ptr->background.green png_ptr->background.red = png_ptr->background.green
= png_ptr->background.blue = png_ptr->background.gray; = png_ptr->background.blue = png_ptr->background.gray;
@ -814,8 +847,9 @@ png_init_read_transformations(png_structp png_ptr)
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
#endif #endif
{ {
/* invert the alpha channel (in tRNS) unless the pixels are /* Invert the alpha channel (in tRNS) unless the pixels are
going to be expanded, in which case leave it for later */ * going to be expanded, in which case leave it for later
*/
int i, istop; int i, istop;
istop=(int)png_ptr->num_trans; istop=(int)png_ptr->num_trans;
for (i=0; i<istop; i++) for (i=0; i<istop; i++)
@ -842,7 +876,7 @@ png_init_read_transformations(png_structp png_ptr)
for (i=0; i<png_ptr->num_trans; i++) for (i=0; i<png_ptr->num_trans; i++)
{ {
if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff) if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
k=1; /* partial transparency is present */ k=1; /* Partial transparency is present */
} }
if (k == 0) if (k == 0)
png_ptr->transformations &= ~PNG_GAMMA; png_ptr->transformations &= ~PNG_GAMMA;
@ -857,8 +891,7 @@ png_init_read_transformations(png_structp png_ptr)
{ {
if (color_type == PNG_COLOR_TYPE_PALETTE) if (color_type == PNG_COLOR_TYPE_PALETTE)
{ {
/* could skip if no transparency and /* Could skip if no transparency */
*/
png_color back, back_1; png_color back, back_1;
png_colorp palette = png_ptr->palette; png_colorp palette = png_ptr->palette;
int num_palette = png_ptr->num_palette; int num_palette = png_ptr->num_palette;
@ -883,10 +916,12 @@ png_init_read_transformations(png_structp png_ptr)
g = (png_ptr->screen_gamma); g = (png_ptr->screen_gamma);
gs = 1.0; gs = 1.0;
break; break;
case PNG_BACKGROUND_GAMMA_FILE: case PNG_BACKGROUND_GAMMA_FILE:
g = 1.0 / (png_ptr->gamma); g = 1.0 / (png_ptr->gamma);
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
break; break;
case PNG_BACKGROUND_GAMMA_UNIQUE: case PNG_BACKGROUND_GAMMA_UNIQUE:
g = 1.0 / (png_ptr->background_gamma); g = 1.0 / (png_ptr->background_gamma);
gs = 1.0 / (png_ptr->background_gamma * gs = 1.0 / (png_ptr->background_gamma *
@ -975,10 +1010,12 @@ png_init_read_transformations(png_structp png_ptr)
g = (png_ptr->screen_gamma); g = (png_ptr->screen_gamma);
gs = 1.0; gs = 1.0;
break; break;
case PNG_BACKGROUND_GAMMA_FILE: case PNG_BACKGROUND_GAMMA_FILE:
g = 1.0 / (png_ptr->gamma); g = 1.0 / (png_ptr->gamma);
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
break; break;
case PNG_BACKGROUND_GAMMA_UNIQUE: case PNG_BACKGROUND_GAMMA_UNIQUE:
g = 1.0 / (png_ptr->background_gamma); g = 1.0 / (png_ptr->background_gamma);
gs = 1.0 / (png_ptr->background_gamma * gs = 1.0 / (png_ptr->background_gamma *
@ -1020,7 +1057,7 @@ png_init_read_transformations(png_structp png_ptr)
} }
} }
else else
/* transformation does not include PNG_BACKGROUND */ /* Transformation does not include PNG_BACKGROUND */
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ #endif /* PNG_READ_BACKGROUND_SUPPORTED */
if (color_type == PNG_COLOR_TYPE_PALETTE) if (color_type == PNG_COLOR_TYPE_PALETTE)
{ {
@ -1227,7 +1264,7 @@ png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
(info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
{ {
info_ptr->channels++; info_ptr->channels++;
/* if adding a true alpha channel not just filler */ /* If adding a true alpha channel not just filler */
#if !defined(PNG_1_0_X) #if !defined(PNG_1_0_X)
if (png_ptr->transformations & PNG_ADD_ALPHA) if (png_ptr->transformations & PNG_ADD_ALPHA)
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
@ -1282,7 +1319,8 @@ png_do_read_transformations(png_structp png_ptr)
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
/* Application has failed to call either png_read_start_image() /* Application has failed to call either png_read_start_image()
* or png_read_update_info() after setting transforms that expand * or png_read_update_info() after setting transforms that expand
* pixels. This check added to libpng-1.2.19 */ * pixels. This check added to libpng-1.2.19
*/
#if (PNG_WARN_UNINITIALIZED_ROW==1) #if (PNG_WARN_UNINITIALIZED_ROW==1)
png_error(png_ptr, "Uninitialized row"); png_error(png_ptr, "Uninitialized row");
#else #else
@ -1335,39 +1373,41 @@ png_do_read_transformations(png_structp png_ptr)
} }
#endif #endif
/* /* From Andreas Dilger e-mail to png-implement, 26 March 1998:
From Andreas Dilger e-mail to png-implement, 26 March 1998: *
* In most cases, the "simple transparency" should be done prior to doing
In most cases, the "simple transparency" should be done prior to doing * gray-to-RGB, or you will have to test 3x as many bytes to check if a
gray-to-RGB, or you will have to test 3x as many bytes to check if a * pixel is transparent. You would also need to make sure that the
pixel is transparent. You would also need to make sure that the * transparency information is upgraded to RGB.
transparency information is upgraded to RGB. *
* To summarize, the current flow is:
To summarize, the current flow is: * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
- Gray + simple transparency -> compare 1 or 2 gray bytes and composite * with background "in place" if transparent,
with background "in place" if transparent, * convert to RGB if necessary
convert to RGB if necessary * - Gray + alpha -> composite with gray background and remove alpha bytes,
- Gray + alpha -> composite with gray background and remove alpha bytes, * convert to RGB if necessary
convert to RGB if necessary *
* To support RGB backgrounds for gray images we need:
To support RGB backgrounds for gray images we need: * - Gray + simple transparency -> convert to RGB + simple transparency,
- Gray + simple transparency -> convert to RGB + simple transparency, compare * compare 3 or 6 bytes and composite with
3 or 6 bytes and composite with background * background "in place" if transparent
"in place" if transparent (3x compare/pixel * (3x compare/pixel compared to doing
compared to doing composite with gray bkgrnd) * composite with gray bkgrnd)
- Gray + alpha -> convert to RGB + alpha, composite with background and * - Gray + alpha -> convert to RGB + alpha, composite with background and
remove alpha bytes (3x float operations/pixel * remove alpha bytes (3x float
compared with composite on gray background) * operations/pixel compared with composite
* on gray background)
Greg's change will do this. The reason it wasn't done before is for *
performance, as this increases the per-pixel operations. If we would check * Greg's change will do this. The reason it wasn't done before is for
in advance if the background was gray or RGB, and position the gray-to-RGB * performance, as this increases the per-pixel operations. If we would check
transform appropriately, then it would save a lot of work/time. * in advance if the background was gray or RGB, and position the gray-to-RGB
* transform appropriately, then it would save a lot of work/time.
*/ */
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
/* if gray -> RGB, do so now only if background is non-gray; else do later /* If gray -> RGB, do so now only if background is non-gray; else do later
* for performance reasons */ * for performance reasons
*/
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
!(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
@ -1444,7 +1484,7 @@ From Andreas Dilger e-mail to png-implement, 26 March 1998:
#endif #endif
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
/* if gray -> RGB, do so now only if we did not do so above */ /* If gray -> RGB, do so now only if we did not do so above */
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
@ -1475,7 +1515,7 @@ From Andreas Dilger e-mail to png-implement, 26 March 1998:
if (png_ptr->transformations & PNG_USER_TRANSFORM) if (png_ptr->transformations & PNG_USER_TRANSFORM)
{ {
if (png_ptr->read_user_transform_fn != NULL) if (png_ptr->read_user_transform_fn != NULL)
(*(png_ptr->read_user_transform_fn)) /* user read transform function */ (*(png_ptr->read_user_transform_fn)) /* User read transform function */
(png_ptr, /* png_ptr */ (png_ptr, /* png_ptr */
&(png_ptr->row_info), /* row_info: */ &(png_ptr->row_info), /* row_info: */
/* png_uint_32 width; width of row */ /* png_uint_32 width; width of row */
@ -1542,6 +1582,7 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
} }
break; break;
} }
case 2: case 2:
{ {
@ -1563,6 +1604,7 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
} }
break; break;
} }
case 4: case 4:
{ {
png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
@ -1654,6 +1696,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
} }
break; break;
} }
case 4: case 4:
{ {
png_bytep bp = row; png_bytep bp = row;
@ -1669,6 +1712,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
} }
break; break;
} }
case 8: case 8:
{ {
png_bytep bp = row; png_bytep bp = row;
@ -1681,6 +1725,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
} }
break; break;
} }
case 16: case 16:
{ {
png_bytep bp = row; png_bytep bp = row;
@ -1702,7 +1747,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
#endif #endif
#if defined(PNG_READ_16_TO_8_SUPPORTED) #if defined(PNG_READ_16_TO_8_SUPPORTED)
/* chop rows of bit depth 16 down to 8 */ /* Chop rows of bit depth 16 down to 8 */
void /* PRIVATE */ void /* PRIVATE */
png_do_chop(png_row_infop row_info, png_bytep row) png_do_chop(png_row_infop row_info, png_bytep row)
{ {
@ -1726,14 +1771,17 @@ 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) / (png_uint_32)65535L; * (png_uint_32)(*(sp + 1))) * 255 + 127)
* / (png_uint_32)65535L;
* *
* GRR: no, I think this is what it really should be: * GRR: no, I think this is what it really should be:
* *dp = (((((png_uint_32)(*sp) << 8) | * *dp = (((((png_uint_32)(*sp) << 8) |
* (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L; * (png_uint_32)(*(sp + 1))) + 128L)
* / (png_uint_32)257L;
* *
* GRR: here's the exact calculation with shifts: * GRR: here's the exact calculation with shifts:
* temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L; * temp = (((png_uint_32)(*sp) << 8) |
* (png_uint_32)(*(sp + 1))) + 128L;
* *dp = (temp - (temp >> 8)) >> 8; * *dp = (temp - (temp >> 8)) >> 8;
* *
* Approximate calculation with shift/add instead of multiply/divide: * Approximate calculation with shift/add instead of multiply/divide:
@ -2123,7 +2171,7 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
#endif #endif
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
/* expand grayscale files to RGB, with or without alpha */ /* Expand grayscale files to RGB, with or without alpha */
void /* PRIVATE */ void /* PRIVATE */
png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
{ {
@ -2206,7 +2254,7 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
#endif #endif
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
/* reduce RGB files to grayscale, with or without alpha /* Reduce RGB files to grayscale, with or without alpha
* using the equation given in Poynton's ColorFAQ at * using the equation given in Poynton's ColorFAQ at
* <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008) * <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008)
* New link: * New link:
@ -2484,18 +2532,22 @@ png_build_grayscale_palette(int bit_depth, png_colorp palette)
num_palette = 2; num_palette = 2;
color_inc = 0xff; color_inc = 0xff;
break; break;
case 2: case 2:
num_palette = 4; num_palette = 4;
color_inc = 0x55; color_inc = 0x55;
break; break;
case 4: case 4:
num_palette = 16; num_palette = 16;
color_inc = 0x11; color_inc = 0x11;
break; break;
case 8: case 8:
num_palette = 256; num_palette = 256;
color_inc = 1; color_inc = 1;
break; break;
default: default:
num_palette = 0; num_palette = 0;
color_inc = 0; color_inc = 0;
@ -2673,7 +2725,7 @@ png_correct_palette(png_structp png_ptr, png_colorp palette,
} }
} }
} }
else /* assume grayscale palette (what else could it be?) */ else /* Assume grayscale palette (what else could it be?) */
{ {
int i; int i;
@ -2749,6 +2801,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 2: case 2:
{ {
#if defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED)
@ -2805,6 +2858,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 4: case 4:
{ {
#if defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED)
@ -2861,6 +2915,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 8: case 8:
{ {
#if defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED)
@ -2893,6 +2948,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 16: case 16:
{ {
#if defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED)
@ -2906,7 +2962,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
if (v == trans_values->gray) if (v == trans_values->gray)
{ {
/* background is already in screen gamma */ /* Background is already in screen gamma */
*sp = (png_byte)((background->gray >> 8) & 0xff); *sp = (png_byte)((background->gray >> 8) & 0xff);
*(sp + 1) = (png_byte)(background->gray & 0xff); *(sp + 1) = (png_byte)(background->gray & 0xff);
} }
@ -2939,6 +2995,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_RGB:
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
@ -2996,7 +3053,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
if (r == trans_values->red && g == trans_values->green && if (r == trans_values->red && g == trans_values->green &&
b == trans_values->blue) b == trans_values->blue)
{ {
/* background is already in screen gamma */ /* Background is already in screen gamma */
*sp = (png_byte)((background->red >> 8) & 0xff); *sp = (png_byte)((background->red >> 8) & 0xff);
*(sp + 1) = (png_byte)(background->red & 0xff); *(sp + 1) = (png_byte)(background->red & 0xff);
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff); *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
@ -3043,6 +3100,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_GRAY_ALPHA:
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
@ -3063,7 +3121,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
else if (a == 0) else if (a == 0)
{ {
/* background is already in screen gamma */ /* Background is already in screen gamma */
*dp = (png_byte)background->gray; *dp = (png_byte)background->gray;
} }
else else
@ -3130,7 +3188,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
else else
#endif #endif
{ {
/* background is already in screen gamma */ /* Background is already in screen gamma */
*dp = (png_byte)((background->gray >> 8) & 0xff); *dp = (png_byte)((background->gray >> 8) & 0xff);
*(dp + 1) = (png_byte)(background->gray & 0xff); *(dp + 1) = (png_byte)(background->gray & 0xff);
} }
@ -3185,6 +3243,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case PNG_COLOR_TYPE_RGB_ALPHA: case PNG_COLOR_TYPE_RGB_ALPHA:
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
@ -3207,7 +3266,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
else if (a == 0) else if (a == 0)
{ {
/* background is already in screen gamma */ /* Background is already in screen gamma */
*dp = (png_byte)background->red; *dp = (png_byte)background->red;
*(dp + 1) = (png_byte)background->green; *(dp + 1) = (png_byte)background->green;
*(dp + 2) = (png_byte)background->blue; *(dp + 2) = (png_byte)background->blue;
@ -3288,7 +3347,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
} }
else if (a == 0) else if (a == 0)
{ {
/* background is already in screen gamma */ /* Background is already in screen gamma */
*dp = (png_byte)((background->red >> 8) & 0xff); *dp = (png_byte)((background->red >> 8) & 0xff);
*(dp + 1) = (png_byte)(background->red & 0xff); *(dp + 1) = (png_byte)(background->red & 0xff);
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff); *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
@ -3443,6 +3502,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case PNG_COLOR_TYPE_RGB_ALPHA: case PNG_COLOR_TYPE_RGB_ALPHA:
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
@ -3480,6 +3540,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_GRAY_ALPHA:
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
@ -3504,6 +3565,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case PNG_COLOR_TYPE_GRAY: case PNG_COLOR_TYPE_GRAY:
{ {
if (row_info->bit_depth == 2) if (row_info->bit_depth == 2)
@ -3524,6 +3586,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
sp++; sp++;
} }
} }
if (row_info->bit_depth == 4) if (row_info->bit_depth == 4)
{ {
sp = row; sp = row;
@ -3537,6 +3600,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
sp++; sp++;
} }
} }
else if (row_info->bit_depth == 8) else if (row_info->bit_depth == 8)
{ {
sp = row; sp = row;
@ -3546,6 +3610,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
sp++; sp++;
} }
} }
else if (row_info->bit_depth == 16) else if (row_info->bit_depth == 16)
{ {
sp = row; sp = row;
@ -3611,6 +3676,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 2: case 2:
{ {
sp = row + (png_size_t)((row_width - 1) >> 2); sp = row + (png_size_t)((row_width - 1) >> 2);
@ -3632,6 +3698,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 4: case 4:
{ {
sp = row + (png_size_t)((row_width - 1) >> 1); sp = row + (png_size_t)((row_width - 1) >> 1);
@ -3696,6 +3763,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
*dp-- = palette[*sp].red; *dp-- = palette[*sp].red;
sp--; sp--;
} }
row_info->bit_depth = 8; row_info->bit_depth = 8;
row_info->pixel_depth = 24; row_info->pixel_depth = 24;
row_info->rowbytes = row_width * 3; row_info->rowbytes = row_width * 3;
@ -3757,6 +3825,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 2: case 2:
{ {
gray = (png_uint_16)((gray&0x03)*0x55); gray = (png_uint_16)((gray&0x03)*0x55);
@ -3780,6 +3849,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
} }
break; break;
} }
case 4: case 4:
{ {
gray = (png_uint_16)((gray&0x0f)*0x11); gray = (png_uint_16)((gray&0x0f)*0x11);
@ -3803,6 +3873,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
break; break;
} }
} }
row_info->bit_depth = 8; row_info->bit_depth = 8;
row_info->pixel_depth = 8; row_info->pixel_depth = 8;
row_info->rowbytes = row_width; row_info->rowbytes = row_width;
@ -3824,6 +3895,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
*dp-- = *sp--; *dp-- = *sp--;
} }
} }
else if (row_info->bit_depth == 16) else if (row_info->bit_depth == 16)
{ {
png_byte gray_high = (gray >> 8) & 0xff; png_byte gray_high = (gray >> 8) & 0xff;
@ -3846,6 +3918,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
*dp-- = *sp--; *dp-- = *sp--;
} }
} }
row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
row_info->channels = 2; row_info->channels = 2;
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
@ -3943,12 +4016,12 @@ png_do_dither(png_row_infop row_info, png_bytep row,
g = *sp++; g = *sp++;
b = *sp++; b = *sp++;
/* this looks real messy, but the compiler will reduce /* This looks real messy, but the compiler will reduce
it down to a reasonable formula. For example, with * it down to a reasonable formula. For example, with
5 bits per color, we get: * 5 bits per color, we get:
p = (((r >> 3) & 0x1f) << 10) | * p = (((r >> 3) & 0x1f) << 10) |
(((g >> 3) & 0x1f) << 5) | * (((g >> 3) & 0x1f) << 5) |
((b >> 3) & 0x1f); * ((b >> 3) & 0x1f);
*/ */
p = (((r >> (8 - PNG_DITHER_RED_BITS)) & p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
((1 << PNG_DITHER_RED_BITS) - 1)) << ((1 << PNG_DITHER_RED_BITS) - 1)) <<
@ -4030,6 +4103,7 @@ png_build_gamma_table(png_structp png_ptr)
if (png_ptr->screen_gamma > .000001) if (png_ptr->screen_gamma > .000001)
g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
else else
g = 1.0; g = 1.0;
@ -4064,8 +4138,9 @@ png_build_gamma_table(png_structp png_ptr)
if (png_ptr->screen_gamma > 0.000001) if (png_ptr->screen_gamma > 0.000001)
g = 1.0 / png_ptr->screen_gamma; g = 1.0 / png_ptr->screen_gamma;
else else
g = png_ptr->gamma; /* probably doing rgb_to_gray */ g = png_ptr->gamma; /* Probably doing rgb_to_gray */
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
@ -4086,8 +4161,10 @@ png_build_gamma_table(png_structp png_ptr)
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
{ {
sig_bit = (int)png_ptr->sig_bit.red; sig_bit = (int)png_ptr->sig_bit.red;
if ((int)png_ptr->sig_bit.green > sig_bit) if ((int)png_ptr->sig_bit.green > sig_bit)
sig_bit = png_ptr->sig_bit.green; sig_bit = png_ptr->sig_bit.green;
if ((int)png_ptr->sig_bit.blue > sig_bit) if ((int)png_ptr->sig_bit.blue > sig_bit)
sig_bit = png_ptr->sig_bit.blue; sig_bit = png_ptr->sig_bit.blue;
} }
@ -4098,6 +4175,7 @@ png_build_gamma_table(png_structp png_ptr)
if (sig_bit > 0) if (sig_bit > 0)
shift = 16 - sig_bit; shift = 16 - sig_bit;
else else
shift = 0; shift = 0;
@ -4109,6 +4187,7 @@ png_build_gamma_table(png_structp png_ptr)
if (shift > 8) if (shift > 8)
shift = 8; shift = 8;
if (shift < 0) if (shift < 0)
shift = 0; shift = 0;
@ -4166,6 +4245,7 @@ png_build_gamma_table(png_structp png_ptr)
(png_uint_32)(256 * png_sizeof(png_uint_16))); (png_uint_32)(256 * png_sizeof(png_uint_16)));
ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4); ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
for (j = 0; j < 256; j++) for (j = 0; j < 256; j++)
{ {
png_ptr->gamma_16_table[i][j] = png_ptr->gamma_16_table[i][j] =
@ -4203,8 +4283,9 @@ png_build_gamma_table(png_structp png_ptr)
if (png_ptr->screen_gamma > 0.000001) if (png_ptr->screen_gamma > 0.000001)
g = 1.0 / png_ptr->screen_gamma; g = 1.0 / png_ptr->screen_gamma;
else else
g = png_ptr->gamma; /* probably doing rgb_to_gray */ g = png_ptr->gamma; /* Probably doing rgb_to_gray */
png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr, png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
(png_uint_32)(num * png_sizeof(png_uint_16p))); (png_uint_32)(num * png_sizeof(png_uint_16p)));
@ -4218,6 +4299,7 @@ png_build_gamma_table(png_structp png_ptr)
ig = (((png_uint_32)i * ig = (((png_uint_32)i *
(png_uint_32)png_gamma_shift[shift]) >> 4); (png_uint_32)png_gamma_shift[shift]) >> 4);
for (j = 0; j < 256; j++) for (j = 0; j < 256; j++)
{ {
png_ptr->gamma_16_from_1[i][j] = png_ptr->gamma_16_from_1[i][j] =
@ -4234,7 +4316,7 @@ png_build_gamma_table(png_structp png_ptr)
#endif #endif
#if defined(PNG_MNG_FEATURES_SUPPORTED) #if defined(PNG_MNG_FEATURES_SUPPORTED)
/* undoes intrapixel differencing */ /* Undoes intrapixel differencing */
void /* PRIVATE */ void /* PRIVATE */
png_do_read_intrapixel(png_row_infop row_info, png_bytep row) png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
{ {
@ -4254,8 +4336,10 @@ png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
if (row_info->color_type == PNG_COLOR_TYPE_RGB) if (row_info->color_type == PNG_COLOR_TYPE_RGB)
bytes_per_pixel = 3; bytes_per_pixel = 3;
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
bytes_per_pixel = 4; bytes_per_pixel = 4;
else else
return; return;
@ -4272,8 +4356,10 @@ png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
if (row_info->color_type == PNG_COLOR_TYPE_RGB) if (row_info->color_type == PNG_COLOR_TYPE_RGB)
bytes_per_pixel = 6; bytes_per_pixel = 6;
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
bytes_per_pixel = 8; bytes_per_pixel = 8;
else else
return; return;

166
pngrutil.c
View File

@ -1,7 +1,7 @@
/* pngrutil.c - utilities to read a PNG file /* pngrutil.c - utilities to read a PNG file
* *
* Last changed in libpng 1.2.37 [May 19, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -21,7 +21,7 @@
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
# if defined(WIN32_WCE_OLD) # if defined(WIN32_WCE_OLD)
/* strtod() function is not supported on WindowsCE */ /* The strtod() function is not supported on WindowsCE */
__inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, char **endptr) __inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, char **endptr)
{ {
double result = 0; double result = 0;
@ -76,7 +76,8 @@ png_get_uint_32(png_bytep buf)
/* Grab a signed 32-bit integer from a buffer in big-endian format. The /* Grab a signed 32-bit integer from a buffer in big-endian format. The
* data is stored in the PNG file in two's complement format, and it is * data is stored in the PNG file in two's complement format, and it is
* assumed that the machine format for signed integers is the same. */ * assumed that the machine format for signed integers is the same.
*/
png_int_32 PNGAPI png_int_32 PNGAPI
png_get_int_32(png_bytep buf) png_get_int_32(png_bytep buf)
{ {
@ -108,21 +109,21 @@ png_read_chunk_header(png_structp png_ptr)
png_byte buf[8]; png_byte buf[8];
png_uint_32 length; png_uint_32 length;
/* read the length and the chunk name */ /* Read the length and the chunk name */
png_read_data(png_ptr, buf, 8); png_read_data(png_ptr, buf, 8);
length = png_get_uint_31(png_ptr, buf); length = png_get_uint_31(png_ptr, buf);
/* put the chunk name into png_ptr->chunk_name */ /* Put the chunk name into png_ptr->chunk_name */
png_memcpy(png_ptr->chunk_name, buf + 4, 4); png_memcpy(png_ptr->chunk_name, buf + 4, 4);
png_debug2(0, "Reading %s chunk, length = %lu", png_debug2(0, "Reading %s chunk, length = %lu",
png_ptr->chunk_name, length); png_ptr->chunk_name, length);
/* reset the crc and run it over the chunk name */ /* Reset the crc and run it over the chunk name */
png_reset_crc(png_ptr); png_reset_crc(png_ptr);
png_calculate_crc(png_ptr, png_ptr->chunk_name, 4); png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
/* check to see if chunk name is valid */ /* Check to see if chunk name is valid */
png_check_chunk_name(png_ptr, png_ptr->chunk_name); png_check_chunk_name(png_ptr, png_ptr->chunk_name);
return length; return length;
@ -132,15 +133,17 @@ png_read_chunk_header(png_structp png_ptr)
void /* PRIVATE */ void /* PRIVATE */
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)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_read_data(png_ptr, buf, length); png_read_data(png_ptr, buf, length);
png_calculate_crc(png_ptr, buf, length); png_calculate_crc(png_ptr, buf, length);
} }
/* Optionally skip data and then check the CRC. Depending on whether we /* Optionally skip data and then check the CRC. Depending on whether we
are reading a ancillary or critical chunk, and how the program has set * are reading a ancillary or critical chunk, and how the program has set
things up, we may calculate the CRC on the data and print a message. * things up, we may calculate the CRC on the data and print a message.
Returns '1' if there was a CRC error, '0' otherwise. */ * Returns '1' if there was a CRC error, '0' otherwise.
*/
int /* PRIVATE */ int /* PRIVATE */
png_crc_finish(png_structp png_ptr, png_uint_32 skip) png_crc_finish(png_structp png_ptr, png_uint_32 skip)
{ {
@ -176,7 +179,8 @@ png_crc_finish(png_structp png_ptr, png_uint_32 skip)
} }
/* Compare the CRC stored in the PNG file with that calculated by libpng from /* Compare the CRC stored in the PNG file with that calculated by libpng from
the data it has read thus far. */ * the data it has read thus far.
*/
int /* PRIVATE */ int /* PRIVATE */
png_crc_error(png_structp png_ptr) png_crc_error(png_structp png_ptr)
{ {
@ -331,14 +335,17 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
png_snprintf(umsg, 52, png_snprintf(umsg, 52,
"Buffer error in compressed datastream in %s chunk", "Buffer error in compressed datastream in %s chunk",
png_ptr->chunk_name); png_ptr->chunk_name);
else if (ret == Z_DATA_ERROR) else if (ret == Z_DATA_ERROR)
png_snprintf(umsg, 52, png_snprintf(umsg, 52,
"Data error in compressed datastream in %s chunk", "Data error in compressed datastream in %s chunk",
png_ptr->chunk_name); png_ptr->chunk_name);
else else
png_snprintf(umsg, 52, png_snprintf(umsg, 52,
"Incomplete compressed datastream in %s chunk", "Incomplete compressed datastream in %s chunk",
png_ptr->chunk_name); png_ptr->chunk_name);
png_warning(png_ptr, umsg); png_warning(png_ptr, umsg);
#else #else
png_warning(png_ptr, png_warning(png_ptr,
@ -383,7 +390,7 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
} }
#endif #endif
/* read and check the IDHR chunk */ /* Read and check the IDHR chunk */
void /* PRIVATE */ void /* PRIVATE */
png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@ -397,7 +404,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
if (png_ptr->mode & PNG_HAVE_IHDR) if (png_ptr->mode & PNG_HAVE_IHDR)
png_error(png_ptr, "Out of place IHDR"); png_error(png_ptr, "Out of place IHDR");
/* check the length */ /* Check the length */
if (length != 13) if (length != 13)
png_error(png_ptr, "Invalid IHDR chunk"); png_error(png_ptr, "Invalid IHDR chunk");
@ -414,7 +421,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
filter_type = buf[11]; filter_type = buf[11];
interlace_type = buf[12]; interlace_type = buf[12];
/* set internal variables */ /* Set internal variables */
png_ptr->width = width; png_ptr->width = width;
png_ptr->height = height; png_ptr->height = height;
png_ptr->bit_depth = (png_byte)bit_depth; png_ptr->bit_depth = (png_byte)bit_depth;
@ -425,25 +432,28 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
png_ptr->compression_type = (png_byte)compression_type; png_ptr->compression_type = (png_byte)compression_type;
/* find number of channels */ /* Find number of channels */
switch (png_ptr->color_type) switch (png_ptr->color_type)
{ {
case PNG_COLOR_TYPE_GRAY: case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_PALETTE: case PNG_COLOR_TYPE_PALETTE:
png_ptr->channels = 1; png_ptr->channels = 1;
break; break;
case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_RGB:
png_ptr->channels = 3; png_ptr->channels = 3;
break; break;
case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_GRAY_ALPHA:
png_ptr->channels = 2; png_ptr->channels = 2;
break; break;
case PNG_COLOR_TYPE_RGB_ALPHA: case PNG_COLOR_TYPE_RGB_ALPHA:
png_ptr->channels = 4; png_ptr->channels = 4;
break; break;
} }
/* set up other useful info */ /* Set up other useful info */
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
png_ptr->channels); png_ptr->channels);
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width); png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
@ -454,7 +464,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
color_type, interlace_type, compression_type, filter_type); color_type, interlace_type, compression_type, filter_type);
} }
/* read and check the palette */ /* Read and check the palette */
void /* PRIVATE */ void /* PRIVATE */
png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@ -468,12 +478,14 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before PLTE"); png_error(png_ptr, "Missing IHDR before PLTE");
else if (png_ptr->mode & PNG_HAVE_IDAT) else if (png_ptr->mode & PNG_HAVE_IDAT)
{ {
png_warning(png_ptr, "Invalid PLTE after IDAT"); png_warning(png_ptr, "Invalid PLTE after IDAT");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
return; return;
} }
else if (png_ptr->mode & PNG_HAVE_PLTE) else if (png_ptr->mode & PNG_HAVE_PLTE)
png_error(png_ptr, "Duplicate PLTE chunk"); png_error(png_ptr, "Duplicate PLTE chunk");
@ -502,6 +514,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
return; return;
} }
else else
{ {
png_error(png_ptr, "Invalid palette chunk"); png_error(png_ptr, "Invalid palette chunk");
@ -526,7 +539,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_byte buf[3]; png_byte buf[3];
png_crc_read(png_ptr, buf, 3); png_crc_read(png_ptr, buf, 3);
/* don't depend upon png_color being any order */ /* Don't depend upon png_color being any order */
palette[i].red = buf[0]; palette[i].red = buf[0];
palette[i].green = buf[1]; palette[i].green = buf[1];
palette[i].blue = buf[2]; palette[i].blue = buf[2];
@ -534,9 +547,10 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
/* If we actually NEED the PLTE chunk (ie for a paletted image), we do /* If we actually NEED the PLTE chunk (ie for a paletted image), we do
whatever the normal CRC configuration tells us. However, if we * whatever the normal CRC configuration tells us. However, if we
have an RGB image, the PLTE can be considered ancillary, so * have an RGB image, the PLTE can be considered ancillary, so
we will act as though it is. */ * we will act as though it is.
*/
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) #if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
#endif #endif
@ -611,7 +625,7 @@ png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */
} }
#if defined(PNG_READ_gAMA_SUPPORTED) #if defined(PNG_READ_gAMA_SUPPORTED)
@ -661,7 +675,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
igamma = (png_fixed_point)png_get_uint_32(buf); igamma = (png_fixed_point)png_get_uint_32(buf);
/* check for zero gamma */ /* Check for zero gamma */
if (igamma == 0) if (igamma == 0)
{ {
png_warning(png_ptr, png_warning(png_ptr,
@ -925,7 +939,7 @@ png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
intent = buf[0]; intent = buf[0];
/* check for bad intent */ /* Check for bad intent */
if (intent >= PNG_sRGB_INTENT_LAST) if (intent >= PNG_sRGB_INTENT_LAST)
{ {
png_warning(png_ptr, "Unknown sRGB intent"); png_warning(png_ptr, "Unknown sRGB intent");
@ -1040,12 +1054,13 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (profile = png_ptr->chunkdata; *profile; profile++) for (profile = png_ptr->chunkdata; *profile; profile++)
/* empty loop to find end of name */ ; /* Empty loop to find end of name */ ;
++profile; ++profile;
/* there should be at least one zero (the compression type byte) /* There should be at least one zero (the compression type byte)
following the separator, and we should be on it */ * following the separator, and we should be on it
*/
if ( profile >= png_ptr->chunkdata + slength - 1) if ( profile >= png_ptr->chunkdata + slength - 1)
{ {
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
@ -1054,7 +1069,7 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
} }
/* compression_type should always be zero */ /* Compression_type should always be zero */
compression_type = *profile++; compression_type = *profile++;
if (compression_type) if (compression_type)
{ {
@ -1152,10 +1167,10 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++) for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++)
/* empty loop to find end of name */ ; /* Empty loop to find end of name */ ;
++entry_start; ++entry_start;
/* a sample depth should follow the separator, and we should be on it */ /* A sample depth should follow the separator, and we should be on it */
if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2) if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
{ {
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
@ -1168,7 +1183,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
entry_size = (new_palette.depth == 8 ? 6 : 10); entry_size = (new_palette.depth == 8 ? 6 : 10);
data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata)); data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));
/* integrity-check the data length */ /* Integrity-check the data length */
if (data_length % entry_size) if (data_length % entry_size)
{ {
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
@ -1236,7 +1251,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
#endif #endif
/* discard all chunk data except the name and stash that */ /* Discard all chunk data except the name and stash that */
new_palette.name = png_ptr->chunkdata; new_palette.name = png_ptr->chunkdata;
png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
@ -1572,7 +1587,7 @@ png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_pCAL_SUPPORTED) #if defined(PNG_READ_pCAL_SUPPORTED)
/* read the pCAL chunk (described in the PNG Extensions document) */ /* Read the pCAL chunk (described in the PNG Extensions document) */
void /* PRIVATE */ void /* PRIVATE */
png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@ -1619,11 +1634,11 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
} }
png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */ png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
png_debug(3, "Finding end of pCAL purpose string"); png_debug(3, "Finding end of pCAL purpose string");
for (buf = png_ptr->chunkdata; *buf; buf++) for (buf = png_ptr->chunkdata; *buf; buf++)
/* empty loop */ ; /* Empty loop */ ;
endptr = png_ptr->chunkdata + slength; endptr = png_ptr->chunkdata + slength;
@ -1706,7 +1721,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_sCAL_SUPPORTED) #if defined(PNG_READ_sCAL_SUPPORTED)
/* read the sCAL chunk */ /* Read the sCAL chunk */
void /* PRIVATE */ void /* PRIVATE */
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@ -1756,9 +1771,9 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
} }
png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */ png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
ep = png_ptr->chunkdata + 1; /* skip unit byte */ ep = png_ptr->chunkdata + 1; /* Skip unit byte */
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
width = png_strtod(png_ptr, ep, &vp); width = png_strtod(png_ptr, ep, &vp);
@ -1780,7 +1795,7 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
for (ep = png_ptr->chunkdata; *ep; ep++) for (ep = png_ptr->chunkdata; *ep; ep++)
/* empty loop */ ; /* Empty loop */ ;
ep++; ep++;
if (png_ptr->chunkdata + slength < ep) if (png_ptr->chunkdata + slength < ep)
@ -1944,7 +1959,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
key[slength] = 0x00; key[slength] = 0x00;
for (text = key; *text; text++) for (text = key; *text; text++)
/* empty loop to find end of key */ ; /* Empty loop to find end of key */ ;
if (text != key + slength) if (text != key + slength)
text++; text++;
@ -1979,7 +1994,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_zTXt_SUPPORTED) #if defined(PNG_READ_zTXt_SUPPORTED)
/* note: this does not correctly handle chunks that are > 64K under DOS */ /* Note: this does not correctly handle chunks that are > 64K under DOS */
void /* PRIVATE */ void /* PRIVATE */
png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@ -2028,7 +2043,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (text = png_ptr->chunkdata; *text; text++) for (text = png_ptr->chunkdata; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
/* zTXt must have some text after the chunkdataword */ /* zTXt must have some text after the chunkdataword */
if (text >= png_ptr->chunkdata + slength - 2) if (text >= png_ptr->chunkdata + slength - 2)
@ -2046,7 +2061,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_warning(png_ptr, "Unknown compression type in zTXt chunk"); png_warning(png_ptr, "Unknown compression type in zTXt chunk");
comp_type = PNG_TEXT_COMPRESSION_zTXt; comp_type = PNG_TEXT_COMPRESSION_zTXt;
} }
text++; /* skip the compression_method byte */ text++; /* Skip the compression_method byte */
} }
prefix_len = text - png_ptr->chunkdata; prefix_len = text - png_ptr->chunkdata;
@ -2083,7 +2098,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_iTXt_SUPPORTED) #if defined(PNG_READ_iTXt_SUPPORTED)
/* note: this does not correctly handle chunks that are > 64K under DOS */ /* Note: this does not correctly handle chunks that are > 64K under DOS */
void /* PRIVATE */ void /* PRIVATE */
png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@ -2133,12 +2148,13 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (lang = png_ptr->chunkdata; *lang; lang++) for (lang = png_ptr->chunkdata; *lang; lang++)
/* empty loop */ ; /* Empty loop */ ;
lang++; /* skip NUL separator */ lang++; /* Skip NUL separator */
/* iTXt must have a language tag (possibly empty), two compression bytes, /* iTXt must have a language tag (possibly empty), two compression bytes,
translated keyword (possibly empty), and possibly some text after the * translated keyword (possibly empty), and possibly some text after the
keyword */ * keyword
*/
if (lang >= png_ptr->chunkdata + slength - 3) if (lang >= png_ptr->chunkdata + slength - 3)
{ {
@ -2154,8 +2170,8 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
for (lang_key = lang; *lang_key; lang_key++) for (lang_key = lang; *lang_key; lang_key++)
/* empty loop */ ; /* Empty loop */ ;
lang_key++; /* skip NUL separator */ lang_key++; /* Skip NUL separator */
if (lang_key >= png_ptr->chunkdata + slength) if (lang_key >= png_ptr->chunkdata + slength)
{ {
@ -2166,8 +2182,8 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
for (text = lang_key; *text; text++) for (text = lang_key; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
text++; /* skip NUL separator */ text++; /* Skip NUL separator */
if (text >= png_ptr->chunkdata + slength) if (text >= png_ptr->chunkdata + slength)
{ {
png_warning(png_ptr, "Malformed iTXt chunk"); png_warning(png_ptr, "Malformed iTXt chunk");
@ -2229,7 +2245,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
PNG_CONST PNG_IDAT; PNG_CONST PNG_IDAT;
#endif #endif
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
} }
@ -2273,7 +2289,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
if (png_ptr->read_user_chunk_fn != NULL) if (png_ptr->read_user_chunk_fn != NULL)
{ {
/* callback to user unknown chunk handler */ /* Callback to user unknown chunk handler */
int ret; int ret;
ret = (*(png_ptr->read_user_chunk_fn)) ret = (*(png_ptr->read_user_chunk_fn))
(png_ptr, &png_ptr->unknown_chunk); (png_ptr, &png_ptr->unknown_chunk);
@ -2302,7 +2318,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_crc_finish(png_ptr, skip); png_crc_finish(png_ptr, skip);
#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED) #if !defined(PNG_READ_USER_CHUNKS_SUPPORTED)
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */
#endif #endif
} }
@ -2550,8 +2566,8 @@ png_do_read_interlace(png_structp png_ptr)
int pass = png_ptr->pass; int pass = png_ptr->pass;
png_uint_32 transformations = png_ptr->transformations; png_uint_32 transformations = png_ptr->transformations;
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
#endif #endif
@ -2759,7 +2775,7 @@ png_do_read_interlace(png_structp png_ptr)
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width); row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);
} }
#if !defined(PNG_READ_PACKSWAP_SUPPORTED) #if !defined(PNG_READ_PACKSWAP_SUPPORTED)
transformations = transformations; /* silence compiler warning */ transformations = transformations; /* Silence compiler warning */
#endif #endif
} }
#endif /* PNG_READ_INTERLACING_SUPPORTED */ #endif /* PNG_READ_INTERLACING_SUPPORTED */
@ -2843,7 +2859,7 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
rp++; rp++;
} }
for (i = 0; i < istop; i++) /* use leftover rp,pp */ for (i = 0; i < istop; i++) /* Use leftover rp,pp */
{ {
int a, b, c, pa, pb, pc, p; int a, b, c, pa, pb, pc, p;
@ -2893,18 +2909,18 @@ png_read_finish_row(png_structp png_ptr)
{ {
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST int png_pass_ystart[7] = {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 */
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif /* PNG_READ_INTERLACING_SUPPORTED */ #endif /* PNG_READ_INTERLACING_SUPPORTED */
#endif #endif
@ -3026,18 +3042,18 @@ png_read_start_row(png_structp png_ptr)
{ {
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST int png_pass_ystart[7] = {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 */
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif #endif
#endif #endif
@ -3174,11 +3190,13 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
} }
#endif #endif
/* align the width on the next larger 8 pixels. Mainly used /* Align the width on the next larger 8 pixels. Mainly used
for interlacing */ * for interlacing
*/
row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
/* calculate the maximum bytes needed, adding a byte and a pixel /* Calculate the maximum bytes needed, adding a byte and a pixel
for safety's sake */ * for safety's sake
*/
row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) + row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +
1 + ((max_pixel_depth + 7) >> 3); 1 + ((max_pixel_depth + 7) >> 3);
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K

36
pngset.c
View File

@ -1,7 +1,7 @@
/* pngset.c - storage of image information into info struct /* pngset.c - storage of image information into info struct
* *
* Last changed in libpng 1.2.36 [May 7, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -140,7 +140,7 @@ png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX) if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)
{ {
png_warning(png_ptr, "Limiting gamma to 21474.83"); png_warning(png_ptr, "Limiting gamma to 21474.83");
png_gamma=PNG_UINT_31_MAX; png_gamma=PNG_UINT_31_MAX;
@ -187,8 +187,9 @@ png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
#endif #endif
/* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in version /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
1.2.1 */ * version 1.2.1
*/
png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
(png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16))); (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)));
if (png_ptr->hist == NULL) if (png_ptr->hist == NULL)
@ -220,7 +221,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
/* check for width and height valid values */ /* Check for width and height valid values */
if (width == 0 || height == 0) if (width == 0 || height == 0)
png_error(png_ptr, "Image width or height is zero in IHDR"); png_error(png_ptr, "Image width or height is zero in IHDR");
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
@ -240,7 +241,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
- 8) /* extra max_pixel_depth pad */ - 8) /* extra max_pixel_depth pad */
png_warning(png_ptr, "Width is too large for libpng to process pixels"); png_warning(png_ptr, "Width is too large for libpng to process pixels");
/* check other values */ /* Check other values */
if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
bit_depth != 8 && bit_depth != 16) bit_depth != 8 && bit_depth != 16)
png_error(png_ptr, "Invalid bit depth in IHDR"); png_error(png_ptr, "Invalid bit depth in IHDR");
@ -306,7 +307,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
info_ptr->channels++; info_ptr->channels++;
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
/* check for potential overflow */ /* Check for potential overflow */
if (width > (PNG_UINT_32_MAX if (width > (PNG_UINT_32_MAX
>> 3) /* 8-byte RGBA pixels */ >> 3) /* 8-byte RGBA pixels */
- 64 /* bigrowbuf hack */ - 64 /* bigrowbuf hack */
@ -516,8 +517,9 @@ png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
#endif #endif
/* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
of num_palette entries, * of num_palette entries, in case of an invalid PNG file that has
in case of an invalid PNG file that has too-large sample values. */ * too-large sample values.
*/
png_ptr->palette = (png_colorp)png_malloc(png_ptr, png_ptr->palette = (png_colorp)png_malloc(png_ptr,
PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color)); PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH * png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH *
@ -767,7 +769,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
else else
#ifdef PNG_iTXt_SUPPORTED #ifdef PNG_iTXt_SUPPORTED
{ {
/* set iTXt data */ /* Set iTXt data */
if (text_ptr[i].lang != NULL) if (text_ptr[i].lang != NULL)
lang_len = png_strlen(text_ptr[i].lang); lang_len = png_strlen(text_ptr[i].lang);
else else
@ -810,8 +812,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
(key_len + lang_len + lang_key_len + text_length + 4), (key_len + lang_len + lang_key_len + text_length + 4),
(int)textp->key); (int)textp->key);
png_memcpy(textp->key, text_ptr[i].key, png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
(png_size_t)(key_len));
*(textp->key + key_len) = '\0'; *(textp->key + key_len) = '\0';
#ifdef PNG_iTXt_SUPPORTED #ifdef PNG_iTXt_SUPPORTED
if (text_ptr[i].compression > 0) if (text_ptr[i].compression > 0)
@ -1039,7 +1040,7 @@ png_set_unknown_chunks(png_structp png_ptr,
png_sizeof(from->name)); png_sizeof(from->name));
to->name[png_sizeof(to->name)-1] = '\0'; to->name[png_sizeof(to->name)-1] = '\0';
to->size = from->size; to->size = from->size;
/* note our location in the read or write sequence */ /* Note our location in the read or write sequence */
to->location = (png_byte)(png_ptr->mode & 0xff); to->location = (png_byte)(png_ptr->mode & 0xff);
if (from->size == 0) if (from->size == 0)
@ -1208,7 +1209,7 @@ png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
#ifndef PNG_1_0_X #ifndef PNG_1_0_X
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
/* function was added to libpng 1.2.0 and should always exist by default */ /* Function was added to libpng 1.2.0 and should always exist by default */
void PNGAPI void PNGAPI
png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags) png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
{ {
@ -1218,7 +1219,7 @@ png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
asm_flags = asm_flags; /* Quiet the compiler */ asm_flags = asm_flags; /* Quiet the compiler */
} }
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
void PNGAPI void PNGAPI
png_set_mmx_thresholds (png_structp png_ptr, png_set_mmx_thresholds (png_structp png_ptr,
png_byte mmx_bitdepth_threshold, png_byte mmx_bitdepth_threshold,
@ -1234,7 +1235,7 @@ png_set_mmx_thresholds (png_structp png_ptr,
#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
/* this function was added to libpng 1.2.6 */ /* This function was added to libpng 1.2.6 */
void PNGAPI void PNGAPI
png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
png_uint_32 user_height_max) png_uint_32 user_height_max)
@ -1243,7 +1244,8 @@ png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
* rejected by png_set_IHDR(). To accept any PNG datastream * rejected by png_set_IHDR(). To accept any PNG datastream
* regardless of dimensions, set both limits to 0x7ffffffL. * regardless of dimensions, set both limits to 0x7ffffffL.
*/ */
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->user_width_max = user_width_max; png_ptr->user_width_max = user_width_max;
png_ptr->user_height_max = user_height_max; png_ptr->user_height_max = user_height_max;
} }

173
pngtest.c
View File

@ -1,7 +1,7 @@
/* pngtest.c - a simple test program to test libpng /* pngtest.c - a simple test program to test libpng
* *
* Last changed in libpng 1.2.36 [May 7, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -65,7 +65,7 @@
#endif #endif
#if !PNG_DEBUG #if !PNG_DEBUG
# define SINGLE_ROWBUF_ALLOC /* makes buffer overruns easier to nail */ # define SINGLE_ROWBUF_ALLOC /* Makes buffer overruns easier to nail */
#endif #endif
/* Turn on CPU timing /* Turn on CPU timing
@ -95,9 +95,9 @@ int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
#include <mem.h> #include <mem.h>
#endif #endif
/* defined so I can write to a file on gui/windowing platforms */ /* Defined so I can write to a file on gui/windowing platforms */
/* #define STDERR stderr */ /* #define STDERR stderr */
#define STDERR stdout /* for DOS */ #define STDERR stdout /* For DOS */
/* In case a system header (e.g., on AIX) defined jmpbuf */ /* In case a system header (e.g., on AIX) defined jmpbuf */
#ifdef jmpbuf #ifdef jmpbuf
@ -109,7 +109,7 @@ int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
# define png_jmpbuf(png_ptr) png_ptr->jmpbuf # define png_jmpbuf(png_ptr) png_ptr->jmpbuf
#endif #endif
/* example of using row callbacks to make a simple progress meter */ /* Example of using row callbacks to make a simple progress meter */
static int status_pass = 1; static int status_pass = 1;
static int status_dots_requested = 0; static int status_dots_requested = 0;
static int status_dots = 1; static int status_dots = 1;
@ -125,7 +125,8 @@ PNGAPI
#endif #endif
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass) read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
{ {
if (png_ptr == NULL || row_number > PNG_UINT_31_MAX) return; if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
return;
if (status_pass != pass) if (status_pass != pass)
{ {
fprintf(stdout, "\n Pass %d: ", pass); fprintf(stdout, "\n Pass %d: ", pass);
@ -152,15 +153,17 @@ PNGAPI
#endif #endif
write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass) write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
{ {
if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7) return; if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7)
return;
fprintf(stdout, "w"); fprintf(stdout, "w");
} }
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
/* Example of using user transform callback (we don't transform anything, /* Example of using user transform callback (we don't transform anything,
but merely examine the row filters. We set this to 256 rather than * but merely examine the row filters. We set this to 256 rather than
5 in case illegal filter values are present.) */ * 5 in case illegal filter values are present.)
*/
static png_uint_32 filters_used[256]; static png_uint_32 filters_used[256];
void void
#ifdef PNG_1_0_X #ifdef PNG_1_0_X
@ -179,8 +182,9 @@ count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
#endif #endif
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
/* example of using user transform callback (we don't transform anything, /* Example of using user transform callback (we don't transform anything,
but merely count the zero samples) */ * but merely count the zero samples)
*/
static png_uint_32 zero_samples; static png_uint_32 zero_samples;
@ -198,7 +202,7 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
png_bytep dp = data; png_bytep dp = data;
if (png_ptr == NULL)return; if (png_ptr == NULL)return;
/* contents of row_info: /* Contents of row_info:
* png_uint_32 width width of row * png_uint_32 width width of row
* png_uint_32 rowbytes number of bytes in row * png_uint_32 rowbytes number of bytes in row
* png_byte color_type color type of pixels * png_byte color_type color type of pixels
@ -207,8 +211,7 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
* png_byte pixel_depth bits per pixel (depth*channels) * png_byte pixel_depth bits per pixel (depth*channels)
*/ */
/* Counts the number of zero samples (or zero pixels if color_type is 3 */
/* counts the number of zero samples (or zero pixels if color_type is 3 */
if (row_info->color_type == 0 || row_info->color_type == 3) if (row_info->color_type == 0 || row_info->color_type == 3)
{ {
@ -218,7 +221,8 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
{ {
if (row_info->bit_depth == 1) if (row_info->bit_depth == 1)
{ {
if (((*dp << pos++ ) & 0x80) == 0) zero_samples++; if (((*dp << pos++ ) & 0x80) == 0)
zero_samples++;
if (pos == 8) if (pos == 8)
{ {
pos = 0; pos = 0;
@ -227,7 +231,8 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
} }
if (row_info->bit_depth == 2) if (row_info->bit_depth == 2)
{ {
if (((*dp << (pos+=2)) & 0xc0) == 0) zero_samples++; if (((*dp << (pos+=2)) & 0xc0) == 0)
zero_samples++;
if (pos == 8) if (pos == 8)
{ {
pos = 0; pos = 0;
@ -236,7 +241,8 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
} }
if (row_info->bit_depth == 4) if (row_info->bit_depth == 4)
{ {
if (((*dp << (pos+=4)) & 0xf0) == 0) zero_samples++; if (((*dp << (pos+=4)) & 0xf0) == 0)
zero_samples++;
if (pos == 8) if (pos == 8)
{ {
pos = 0; pos = 0;
@ -244,7 +250,8 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
} }
} }
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
if (*dp++ == 0) zero_samples++; if (*dp++ == 0)
zero_samples++;
if (row_info->bit_depth == 16) if (row_info->bit_depth == 16)
{ {
if ((*dp | *(dp+1)) == 0) zero_samples++; if ((*dp | *(dp+1)) == 0) zero_samples++;
@ -252,7 +259,7 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
} }
} }
} }
else /* other color types */ else /* Other color types */
{ {
png_uint_32 n, nstop; png_uint_32 n, nstop;
int channel; int channel;
@ -264,7 +271,8 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
for (channel = 0; channel < color_channels; channel++) for (channel = 0; channel < color_channels; channel++)
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
if (*dp++ == 0) zero_samples++; if (*dp++ == 0)
zero_samples++;
if (row_info->bit_depth == 16) if (row_info->bit_depth == 16)
{ {
if ((*dp | *(dp+1)) == 0) zero_samples++; if ((*dp | *(dp+1)) == 0) zero_samples++;
@ -274,7 +282,8 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
if (row_info->color_type > 3) if (row_info->color_type > 3)
{ {
dp++; dp++;
if (row_info->bit_depth == 16)dp++; if (row_info->bit_depth == 16)
dp++;
} }
} }
} }
@ -285,12 +294,13 @@ static int wrote_question = 0;
#if defined(PNG_NO_STDIO) #if defined(PNG_NO_STDIO)
/* START of code to validate stdio-free compilation */ /* START of code to validate stdio-free compilation */
/* These copies of the default read/write functions come from pngrio.c and */ /* These copies of the default read/write functions come from pngrio.c and
/* pngwio.c. They allow "don't include stdio" testing of the library. */ * pngwio.c. They allow "don't include stdio" testing of the library.
/* This is the function that does the actual reading of data. If you are * This is the function that does the actual reading of data. If you are
not reading from a standard C stream, you should create a replacement * not reading from a standard C stream, you should create a replacement
read_data function and use it at run time with png_set_read_fn(), rather * read_data function and use it at run time with png_set_read_fn(), rather
than changing the library. */ * than changing the library.
*/
#ifndef USE_FAR_KEYWORD #ifndef USE_FAR_KEYWORD
static void static void
@ -309,7 +319,7 @@ pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
} }
} }
#else #else
/* this is the model-independent version. Since the standard I/O library /* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy can't handle far buffers in the medium and small models, we have to copy
the data. the data.
*/ */
@ -341,7 +351,7 @@ pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
read = MIN(NEAR_BUF_SIZE, remaining); read = MIN(NEAR_BUF_SIZE, remaining);
READFILE(io_ptr, buf, 1, err); READFILE(io_ptr, buf, 1, err);
png_memcpy(data, buf, read); /* copy far buffer to near buffer */ png_memcpy(data, buf, read); /* Copy far buffer to near buffer */
if (err != read) if (err != read)
break; break;
else else
@ -352,9 +362,7 @@ pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
while (remaining != 0); while (remaining != 0);
} }
if (check != length) if (check != length)
{
png_error(png_ptr, "read Error"); png_error(png_ptr, "read Error");
}
} }
#endif /* USE_FAR_KEYWORD */ #endif /* USE_FAR_KEYWORD */
@ -363,14 +371,15 @@ static void
pngtest_flush(png_structp png_ptr) pngtest_flush(png_structp png_ptr)
{ {
/* Do nothing; fflush() is said to be just a waste of energy. */ /* Do nothing; fflush() is said to be just a waste of energy. */
png_ptr = png_ptr; /* stifle compiler warning */ png_ptr = png_ptr; /* Stifle compiler warning */
} }
#endif #endif
/* This is the function that does the actual writing of data. If you are /* This is the function that does the actual writing of data. If you are
not writing to a standard C stream, you should create a replacement * not writing to a standard C stream, you should create a replacement
write_data function and use it at run time with png_set_write_fn(), rather * write_data function and use it at run time with png_set_write_fn(), rather
than changing the library. */ * than changing the library.
*/
#ifndef USE_FAR_KEYWORD #ifndef USE_FAR_KEYWORD
static void static void
pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length) pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@ -384,7 +393,7 @@ pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
} }
} }
#else #else
/* this is the model-independent version. Since the standard I/O library /* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy can't handle far buffers in the medium and small models, we have to copy
the data. the data.
*/ */
@ -415,7 +424,7 @@ pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
do do
{ {
written = MIN(NEAR_BUF_SIZE, remaining); written = MIN(NEAR_BUF_SIZE, remaining);
png_memcpy(buf, data, written); /* copy far buffer to near buffer */ png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
WRITEFILE(io_ptr, buf, written, err); WRITEFILE(io_ptr, buf, written, err);
if (err != written) if (err != written)
break; break;
@ -457,7 +466,8 @@ pngtest_error(png_structp png_ptr, png_const_charp message)
{ {
pngtest_warning(png_ptr, message); pngtest_warning(png_ptr, message);
/* We can return because png_error calls the default handler, which is /* We can return because png_error calls the default handler, which is
* actually OK in this case. */ * actually OK in this case.
*/
} }
#endif /* PNG_NO_STDIO */ #endif /* PNG_NO_STDIO */
/* END of code to validate stdio-free compilation */ /* END of code to validate stdio-free compilation */
@ -466,13 +476,14 @@ pngtest_error(png_structp png_ptr, png_const_charp message)
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
/* Allocate memory. For reasonable files, size should never exceed /* Allocate memory. For reasonable files, size should never exceed
64K. However, zlib may allocate more then 64K if you don't tell * 64K. However, zlib may allocate more then 64K if you don't tell
it not to. See zconf.h and png.h for more information. zlib does * it not to. See zconf.h and png.h for more information. zlib does
need to allocate exactly 64K, so whatever you call here must * need to allocate exactly 64K, so whatever you call here must
have the ability to do that. * have the ability to do that.
*
This piece of code can be compiled to validate max 64K allocations * This piece of code can be compiled to validate max 64K allocations
by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */ * by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K.
*/
typedef struct memory_information typedef struct memory_information
{ {
png_uint_32 size; png_uint_32 size;
@ -495,7 +506,8 @@ png_debug_malloc(png_structp png_ptr, png_uint_32 size)
{ {
/* png_malloc has already tested for NULL; png_create_struct calls /* png_malloc has already tested for NULL; png_create_struct calls
png_debug_malloc directly, with png_ptr == NULL which is OK */ * png_debug_malloc directly, with png_ptr == NULL which is OK
*/
if (size == 0) if (size == 0)
return (NULL); return (NULL);
@ -592,7 +604,7 @@ png_debug_free(png_structp png_ptr, png_voidp ptr)
/* Demonstration of user chunk support of the sTER and vpAg chunks */ /* Demonstration of user chunk support of the sTER and vpAg chunks */
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
/* (sTER is a public chunk not yet understood by libpng. vpAg is a private /* (sTER is a public chunk not yet known by libpng. vpAg is a private
chunk used in ImageMagick to store "virtual page" size). */ chunk used in ImageMagick to store "virtual page" size). */
static png_uint_32 user_chunk_data[4]; static png_uint_32 user_chunk_data[4];
@ -609,12 +621,12 @@ static int read_user_chunk_callback(png_struct *png_ptr,
png_uint_32 png_uint_32
*my_user_chunk_data; *my_user_chunk_data;
/* Return one of the following: */ /* Return one of the following:
/* return (-n); chunk had an error */ * return (-n); chunk had an error
/* return (0); did not recognize */ * return (0); did not recognize
/* return (n); success */ * return (n); success
*
/* The unknown chunk structure contains the chunk data: * The unknown chunk structure contains the chunk data:
* png_byte name[5]; * png_byte name[5];
* png_byte *data; * png_byte *data;
* png_size_t size; * png_size_t size;
@ -634,6 +646,7 @@ static int read_user_chunk_callback(png_struct *png_ptr,
my_user_chunk_data[0]=chunk->data[0]+1; my_user_chunk_data[0]=chunk->data[0]+1;
return (1); return (1);
} }
if (chunk->name[0] != 118 || chunk->name[1] != 112 || /* v p */ if (chunk->name[0] != 118 || chunk->name[1] != 112 || /* v p */
chunk->name[2] != 65 || chunk->name[3] != 103) /* A g */ chunk->name[2] != 65 || chunk->name[3] != 103) /* A g */
return (0); /* Did not recognize */ return (0); /* Did not recognize */
@ -906,10 +919,8 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_fixed_point gamma; png_fixed_point gamma;
if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma)) if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))
{
png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma); png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
} }
}
#endif #endif
#else /* Use floating point versions */ #else /* Use floating point versions */
#if defined(PNG_FLOATING_POINT_SUPPORTED) #if defined(PNG_FLOATING_POINT_SUPPORTED)
@ -930,13 +941,11 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
double gamma; double gamma;
if (png_get_gAMA(read_ptr, read_info_ptr, &gamma)) if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
{
png_set_gAMA(write_ptr, write_info_ptr, gamma); png_set_gAMA(write_ptr, write_info_ptr, gamma);
} }
}
#endif #endif
#endif /* floating point */ #endif /* Floating point */
#endif /* fixed point */ #endif /* Fixed point */
#if defined(PNG_iCCP_SUPPORTED) #if defined(PNG_iCCP_SUPPORTED)
{ {
png_charp name; png_charp name;
@ -957,20 +966,16 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
int intent; int intent;
if (png_get_sRGB(read_ptr, read_info_ptr, &intent)) if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
{
png_set_sRGB(write_ptr, write_info_ptr, intent); png_set_sRGB(write_ptr, write_info_ptr, intent);
} }
}
#endif #endif
{ {
png_colorp palette; png_colorp palette;
int num_palette; int num_palette;
if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette)) if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))
{
png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette); png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
} }
}
#if defined(PNG_bKGD_SUPPORTED) #if defined(PNG_bKGD_SUPPORTED)
{ {
png_color_16p background; png_color_16p background;
@ -986,10 +991,8 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_uint_16p hist; png_uint_16p hist;
if (png_get_hIST(read_ptr, read_info_ptr, &hist)) if (png_get_hIST(read_ptr, read_info_ptr, &hist))
{
png_set_hIST(write_ptr, write_info_ptr, hist); png_set_hIST(write_ptr, write_info_ptr, hist);
} }
}
#endif #endif
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
{ {
@ -1024,20 +1027,16 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
int unit_type; int unit_type;
if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type)) if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))
{
png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type); png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
} }
}
#endif #endif
#if defined(PNG_sBIT_SUPPORTED) #if defined(PNG_sBIT_SUPPORTED)
{ {
png_color_8p sig_bit; png_color_8p sig_bit;
if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit)) if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
{
png_set_sBIT(write_ptr, write_info_ptr, sig_bit); png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
} }
}
#endif #endif
#if defined(PNG_sCAL_SUPPORTED) #if defined(PNG_sCAL_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
@ -1086,9 +1085,10 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
png_set_tIME(write_ptr, write_info_ptr, mod_time); png_set_tIME(write_ptr, write_info_ptr, mod_time);
#if defined(PNG_TIME_RFC1123_SUPPORTED) #if defined(PNG_TIME_RFC1123_SUPPORTED)
/* we have to use png_memcpy instead of "=" because the string /* We have to use png_memcpy instead of "=" because the string
pointed to by png_convert_to_rfc1123() gets free'ed before * pointed to by png_convert_to_rfc1123() gets free'ed before
we use it */ * we use it.
*/
png_memcpy(tIME_string, png_memcpy(tIME_string,
png_convert_to_rfc1123(read_ptr, mod_time), png_convert_to_rfc1123(read_ptr, mod_time),
png_sizeof(tIME_string)); png_sizeof(tIME_string));
@ -1130,9 +1130,10 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_size_t i; png_size_t i;
png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns, png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
num_unknowns); num_unknowns);
/* copy the locations from the read_info_ptr. The automatically /* Copy the locations from the read_info_ptr. The automatically
generated locations in write_info_ptr are wrong because we * generated locations in write_info_ptr are wrong because we
haven't written anything yet */ * haven't written anything yet.
*/
for (i = 0; i < (png_size_t)num_unknowns; i++) for (i = 0; i < (png_size_t)num_unknowns; i++)
png_set_unknown_chunk_location(write_ptr, write_info_ptr, i, png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
unknowns[i].location); unknowns[i].location);
@ -1144,7 +1145,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_debug(0, "Writing info struct"); png_debug(0, "Writing info struct");
/* If we wanted, we could write info in two steps: /* If we wanted, we could write info in two steps:
png_write_info_before_PLTE(write_ptr, write_info_ptr); * png_write_info_before_PLTE(write_ptr, write_info_ptr);
*/ */
png_write_info(write_ptr, write_info_ptr); png_write_info(write_ptr, write_info_ptr);
@ -1272,7 +1273,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
png_set_tIME(write_ptr, write_end_info_ptr, mod_time); png_set_tIME(write_ptr, write_end_info_ptr, mod_time);
#if defined(PNG_TIME_RFC1123_SUPPORTED) #if defined(PNG_TIME_RFC1123_SUPPORTED)
/* we have to use png_memcpy instead of "=" because the string /* We have to use png_memcpy instead of "=" because the string
pointed to by png_convert_to_rfc1123() gets free'ed before pointed to by png_convert_to_rfc1123() gets free'ed before
we use it */ we use it */
png_memcpy(tIME_string, png_memcpy(tIME_string,
@ -1295,9 +1296,10 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_size_t i; png_size_t i;
png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns, png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
num_unknowns); num_unknowns);
/* copy the locations from the read_info_ptr. The automatically /* Copy the locations from the read_info_ptr. The automatically
generated locations in write_end_info_ptr are wrong because we * generated locations in write_end_info_ptr are wrong because we
haven't written the end_info yet */ * haven't written the end_info yet.
*/
for (i = 0; i < (png_size_t)num_unknowns; i++) for (i = 0; i < (png_size_t)num_unknowns; i++)
png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i, png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
unknowns[i].location); unknowns[i].location);
@ -1420,7 +1422,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
return (0); return (0);
} }
/* input and output filenames */ /* Input and output filenames */
#ifdef RISCOS #ifdef RISCOS
static PNG_CONST char *inname = "pngtest/png"; static PNG_CONST char *inname = "pngtest/png";
static PNG_CONST char *outname = "pngout/png"; static PNG_CONST char *outname = "pngout/png";
@ -1449,9 +1451,10 @@ main(int argc, char *argv[])
(long)png_sizeof(png_struct), (long)png_sizeof(png_info)); (long)png_sizeof(png_struct), (long)png_sizeof(png_info));
/* Do some consistency checking on the memory allocation settings, I'm /* Do some consistency checking on the memory allocation settings, I'm
not sure this matters, but it is nice to know, the first of these * not sure this matters, but it is nice to know, the first of these
tests should be impossible because of the way the macros are set * tests should be impossible because of the way the macros are set
in pngconf.h */ * in pngconf.h
*/
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n"); fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
#endif #endif
@ -1681,4 +1684,4 @@ main(int argc, char *argv[])
} }
/* Generate a compiler error if there is an old png.h in the search path. */ /* Generate a compiler error if there is an old png.h in the search path. */
typedef version_1_2_37rc01 your_png_h_is_not_version_1_2_37rc01; typedef version_1_2_37beta03 your_png_h_is_not_version_1_2_37beta03;

58
pngtrans.c
View File

@ -1,9 +1,9 @@
/* 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)
* *
* Last changed in libpng 1.2.30 [August 15, 2008] * Last changed in libpng 1.2.36 [May 14, 2009]
* 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) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@ -13,35 +13,38 @@
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* turn on BGR-to-RGB mapping */ /* Turn on BGR-to-RGB mapping */
void PNGAPI void PNGAPI
png_set_bgr(png_structp png_ptr) png_set_bgr(png_structp png_ptr)
{ {
png_debug(1, "in png_set_bgr"); png_debug(1, "in png_set_bgr");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_BGR; png_ptr->transformations |= PNG_BGR;
} }
#endif #endif
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* turn on 16 bit byte swapping */ /* Turn on 16 bit byte swapping */
void PNGAPI void PNGAPI
png_set_swap(png_structp png_ptr) png_set_swap(png_structp png_ptr)
{ {
png_debug(1, "in png_set_swap"); png_debug(1, "in png_set_swap");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (png_ptr->bit_depth == 16) if (png_ptr->bit_depth == 16)
png_ptr->transformations |= PNG_SWAP_BYTES; png_ptr->transformations |= PNG_SWAP_BYTES;
} }
#endif #endif
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
/* turn on pixel packing */ /* Turn on pixel packing */
void PNGAPI void PNGAPI
png_set_packing(png_structp png_ptr) png_set_packing(png_structp png_ptr)
{ {
png_debug(1, "in png_set_packing"); png_debug(1, "in png_set_packing");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (png_ptr->bit_depth < 8) if (png_ptr->bit_depth < 8)
{ {
png_ptr->transformations |= PNG_PACK; png_ptr->transformations |= PNG_PACK;
@ -51,12 +54,13 @@ png_set_packing(png_structp png_ptr)
#endif #endif
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
/* turn on packed pixel swapping */ /* Turn on packed pixel swapping */
void PNGAPI void PNGAPI
png_set_packswap(png_structp png_ptr) png_set_packswap(png_structp png_ptr)
{ {
png_debug(1, "in png_set_packswap"); png_debug(1, "in png_set_packswap");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (png_ptr->bit_depth < 8) if (png_ptr->bit_depth < 8)
png_ptr->transformations |= PNG_PACKSWAP; png_ptr->transformations |= PNG_PACKSWAP;
} }
@ -67,7 +71,8 @@ void PNGAPI
png_set_shift(png_structp png_ptr, png_color_8p true_bits) png_set_shift(png_structp png_ptr, png_color_8p true_bits)
{ {
png_debug(1, "in png_set_shift"); png_debug(1, "in png_set_shift");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_SHIFT; png_ptr->transformations |= PNG_SHIFT;
png_ptr->shift = *true_bits; png_ptr->shift = *true_bits;
} }
@ -99,7 +104,8 @@ void PNGAPI
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{ {
png_debug(1, "in png_set_filler"); png_debug(1, "in png_set_filler");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_FILLER; png_ptr->transformations |= PNG_FILLER;
png_ptr->filler = (png_byte)filler; png_ptr->filler = (png_byte)filler;
if (filler_loc == PNG_FILLER_AFTER) if (filler_loc == PNG_FILLER_AFTER)
@ -132,7 +138,8 @@ void PNGAPI
png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{ {
png_debug(1, "in png_set_add_alpha"); png_debug(1, "in png_set_add_alpha");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_set_filler(png_ptr, filler, filler_loc); png_set_filler(png_ptr, filler, filler_loc);
png_ptr->transformations |= PNG_ADD_ALPHA; png_ptr->transformations |= PNG_ADD_ALPHA;
} }
@ -146,7 +153,8 @@ void PNGAPI
png_set_swap_alpha(png_structp png_ptr) png_set_swap_alpha(png_structp png_ptr)
{ {
png_debug(1, "in png_set_swap_alpha"); png_debug(1, "in png_set_swap_alpha");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_SWAP_ALPHA; png_ptr->transformations |= PNG_SWAP_ALPHA;
} }
#endif #endif
@ -157,7 +165,8 @@ void PNGAPI
png_set_invert_alpha(png_structp png_ptr) png_set_invert_alpha(png_structp png_ptr)
{ {
png_debug(1, "in png_set_invert_alpha"); png_debug(1, "in png_set_invert_alpha");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_INVERT_ALPHA; png_ptr->transformations |= PNG_INVERT_ALPHA;
} }
#endif #endif
@ -167,11 +176,12 @@ void PNGAPI
png_set_invert_mono(png_structp png_ptr) png_set_invert_mono(png_structp png_ptr)
{ {
png_debug(1, "in png_set_invert_mono"); png_debug(1, "in png_set_invert_mono");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_INVERT_MONO; png_ptr->transformations |= PNG_INVERT_MONO;
} }
/* invert monochrome grayscale data */ /* Invert monochrome grayscale data */
void /* PRIVATE */ void /* PRIVATE */
png_do_invert(png_row_infop row_info, png_bytep row) png_do_invert(png_row_infop row_info, png_bytep row)
{ {
@ -226,7 +236,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
#endif #endif
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* swaps byte order on 16 bit depth images */ /* Swaps byte order on 16 bit depth images */
void /* PRIVATE */ void /* PRIVATE */
png_do_swap(png_row_infop row_info, png_bytep row) png_do_swap(png_row_infop row_info, png_bytep row)
{ {
@ -357,7 +367,7 @@ static PNG_CONST png_byte fourbppswaptable[256] = {
0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
}; };
/* swaps pixel packing order within bytes */ /* Swaps pixel packing order within bytes */
void /* PRIVATE */ void /* PRIVATE */
png_do_packswap(png_row_infop row_info, png_bytep row) png_do_packswap(png_row_infop row_info, png_bytep row)
{ {
@ -389,7 +399,7 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
/* remove filler or alpha byte(s) */ /* Remove filler or alpha byte(s) */
void /* PRIVATE */ void /* PRIVATE */
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
{ {
@ -547,7 +557,7 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
#endif #endif
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* swaps red and blue bytes within a pixel */ /* Swaps red and blue bytes within a pixel */
void /* PRIVATE */ void /* PRIVATE */
png_do_bgr(png_row_infop row_info, png_bytep row) png_do_bgr(png_row_infop row_info, png_bytep row)
{ {
@ -631,7 +641,8 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp
user_transform_ptr, int user_transform_depth, int user_transform_channels) user_transform_ptr, int user_transform_depth, int user_transform_channels)
{ {
png_debug(1, "in png_set_user_transform_info"); png_debug(1, "in png_set_user_transform_info");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
png_ptr->user_transform_ptr = user_transform_ptr; png_ptr->user_transform_ptr = user_transform_ptr;
png_ptr->user_transform_depth = (png_byte)user_transform_depth; png_ptr->user_transform_depth = (png_byte)user_transform_depth;
@ -652,7 +663,8 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp
png_voidp PNGAPI png_voidp PNGAPI
png_get_user_transform_ptr(png_structp png_ptr) png_get_user_transform_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
return ((png_voidp)png_ptr->user_transform_ptr); return ((png_voidp)png_ptr->user_transform_ptr);
#else #else

103
pngwio.c
View File

@ -1,7 +1,7 @@
/* pngwio.c - functions for data output /* pngwio.c - functions for data output
* *
* Last changed in libpng 1.2.36 [May 7, 2009] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -20,10 +20,11 @@
#ifdef PNG_WRITE_SUPPORTED #ifdef PNG_WRITE_SUPPORTED
/* Write the data to whatever output you are using. The default routine /* Write the data to whatever output you are using. The default routine
writes to a file pointer. Note that this routine sometimes gets called * writes to a file pointer. Note that this routine sometimes gets called
with very small lengths, so you should implement some kind of simple * with very small lengths, so you should implement some kind of simple
buffering if you are using unbuffered writes. This should never be asked * buffering if you are using unbuffered writes. This should never be asked
to write more than 64K on a 16 bit machine. */ * to write more than 64K on a 16 bit machine.
*/
void /* PRIVATE */ void /* PRIVATE */
png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@ -36,9 +37,10 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
/* This is the function that does the actual writing of data. If you are /* This is the function that does the actual writing of data. If you are
not writing to a standard C stream, you should create a replacement * not writing to a standard C stream, you should create a replacement
write_data function and use it at run time with png_set_write_fn(), rather * write_data function and use it at run time with png_set_write_fn(), rather
than changing the library. */ * than changing the library.
*/
#ifndef USE_FAR_KEYWORD #ifndef USE_FAR_KEYWORD
void PNGAPI void PNGAPI
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@ -56,10 +58,10 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_error(png_ptr, "Write Error"); png_error(png_ptr, "Write Error");
} }
#else #else
/* this is the model-independent version. Since the standard I/O library /* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy * can't handle far buffers in the medium and small models, we have to copy
the data. * the data.
*/ */
#define NEAR_BUF_SIZE 1024 #define NEAR_BUF_SIZE 1024
#define MIN(a,b) (a <= b ? a : b) #define MIN(a,b) (a <= b ? a : b)
@ -93,7 +95,7 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
do do
{ {
written = MIN(NEAR_BUF_SIZE, remaining); written = MIN(NEAR_BUF_SIZE, remaining);
png_memcpy(buf, data, written); /* copy far buffer to near buffer */ png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
#if defined(_WIN32_WCE) #if defined(_WIN32_WCE)
if ( !WriteFile(io_ptr, buf, written, &err, NULL) ) if ( !WriteFile(io_ptr, buf, written, &err, NULL) )
err = 0; err = 0;
@ -102,8 +104,10 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
#endif #endif
if (err != written) if (err != written)
break; break;
else else
check += err; check += err;
data += written; data += written;
remaining -= written; remaining -= written;
} }
@ -117,8 +121,9 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
#endif #endif
/* This function is called to output any data pending writing (normally /* This function is called to output any data pending writing (normally
to disk). After png_flush is called, there should be no data pending * to disk). After png_flush is called, there should be no data pending
writing in any buffers. */ * writing in any buffers.
*/
#if defined(PNG_WRITE_FLUSH_SUPPORTED) #if defined(PNG_WRITE_FLUSH_SUPPORTED)
void /* PRIVATE */ void /* PRIVATE */
png_flush(png_structp png_ptr) png_flush(png_structp png_ptr)
@ -134,7 +139,8 @@ png_default_flush(png_structp png_ptr)
#if !defined(_WIN32_WCE) #if !defined(_WIN32_WCE)
png_FILE_p io_ptr; png_FILE_p io_ptr;
#endif #endif
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if !defined(_WIN32_WCE) #if !defined(_WIN32_WCE)
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
fflush(io_ptr); fflush(io_ptr);
@ -144,43 +150,47 @@ png_default_flush(png_structp png_ptr)
#endif #endif
/* This function allows the application to supply new output functions for /* This function allows the application to supply new output functions for
libpng if standard C streams aren't being used. * libpng if standard C streams aren't being used.
*
This function takes as its arguments: * This function takes as its arguments:
png_ptr - pointer to a png output data structure * png_ptr - pointer to a png output data structure
io_ptr - pointer to user supplied structure containing info about * io_ptr - pointer to user supplied structure containing info about
the output functions. May be NULL. * the output functions. May be NULL.
write_data_fn - pointer to a new output function that takes as its * write_data_fn - pointer to a new output function that takes as its
arguments a pointer to a png_struct, a pointer to * arguments a pointer to a png_struct, a pointer to
data to be written, and a 32-bit unsigned int that is * data to be written, and a 32-bit unsigned int that is
the number of bytes to be written. The new write * the number of bytes to be written. The new write
function should call png_error(png_ptr, "Error msg") * function should call png_error(png_ptr, "Error msg")
to exit and output any fatal error messages. May be * to exit and output any fatal error messages. May be
NULL, in which case libpng's default function will * NULL, in which case libpng's default function will
be used. * be used.
flush_data_fn - pointer to a new flush function that takes as its * flush_data_fn - pointer to a new flush function that takes as its
arguments a pointer to a png_struct. After a call to * arguments a pointer to a png_struct. After a call to
the flush function, there should be no data in any buffers * the flush function, there should be no data in any buffers
or pending transmission. If the output method doesn't do * or pending transmission. If the output method doesn't do
any buffering of ouput, a function prototype must still be * any buffering of ouput, a function prototype must still be
supplied although it doesn't have to do anything. If * supplied although it doesn't have to do anything. If
PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile * PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
time, output_flush_fn will be ignored, although it must be * time, output_flush_fn will be ignored, although it must be
supplied for compatibility. May be NULL, in which case * supplied for compatibility. May be NULL, in which case
libpng's default function will be used, if * libpng's default function will be used, if
PNG_WRITE_FLUSH_SUPPORTED is defined. This is not * PNG_WRITE_FLUSH_SUPPORTED is defined. This is not
a good idea if io_ptr does not point to a standard * a good idea if io_ptr does not point to a standard
*FILE structure. */ * *FILE structure.
*/
void PNGAPI void PNGAPI
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->io_ptr = io_ptr; png_ptr->io_ptr = io_ptr;
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
if (write_data_fn != NULL) if (write_data_fn != NULL)
png_ptr->write_data_fn = write_data_fn; png_ptr->write_data_fn = write_data_fn;
else else
png_ptr->write_data_fn = png_default_write_data; png_ptr->write_data_fn = png_default_write_data;
#else #else
@ -191,6 +201,7 @@ png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
if (output_flush_fn != NULL) if (output_flush_fn != NULL)
png_ptr->output_flush_fn = output_flush_fn; png_ptr->output_flush_fn = output_flush_fn;
else else
png_ptr->output_flush_fn = png_default_flush; png_ptr->output_flush_fn = png_default_flush;
#else #else
@ -217,9 +228,11 @@ void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
void FAR *far_ptr; void FAR *far_ptr;
FP_OFF(near_ptr) = FP_OFF(ptr); FP_OFF(near_ptr) = FP_OFF(ptr);
far_ptr = (void FAR *)near_ptr; far_ptr = (void FAR *)near_ptr;
if (check != 0) if (check != 0)
if (FP_SEG(ptr) != FP_SEG(far_ptr)) if (FP_SEG(ptr) != FP_SEG(far_ptr))
png_error(png_ptr, "segment lost in conversion"); png_error(png_ptr, "segment lost in conversion");
return(near_ptr); return(near_ptr);
} }
# else # else
@ -229,9 +242,11 @@ void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
void FAR *far_ptr; void FAR *far_ptr;
near_ptr = (void FAR *)ptr; near_ptr = (void FAR *)ptr;
far_ptr = (void FAR *)near_ptr; far_ptr = (void FAR *)near_ptr;
if (check != 0) if (check != 0)
if (far_ptr != ptr) if (far_ptr != ptr)
png_error(png_ptr, "segment lost in conversion"); png_error(png_ptr, "segment lost in conversion");
return(near_ptr); return(near_ptr);
} }
# endif # endif

159
pngwrite.c
View File

@ -1,14 +1,14 @@
/* pngwrite.c - general routines to write a PNG file /* pngwrite.c - general routines to write a PNG file
* *
* Last changed in libpng 1.2.34 [December 18, 2008] * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
/* get internal access to png.h */ /* Get internal access to png.h */
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
#ifdef PNG_WRITE_SUPPORTED #ifdef PNG_WRITE_SUPPORTED
@ -30,7 +30,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
return; return;
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
{ {
png_write_sig(png_ptr); /* write PNG signature */ png_write_sig(png_ptr); /* Write PNG signature */
#if defined(PNG_MNG_FEATURES_SUPPORTED) #if defined(PNG_MNG_FEATURES_SUPPORTED)
if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted)) if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))
{ {
@ -38,7 +38,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
png_ptr->mng_features_permitted=0; png_ptr->mng_features_permitted=0;
} }
#endif #endif
/* write IHDR information. */ /* Write IHDR information. */
png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
info_ptr->filter_type, info_ptr->filter_type,
@ -47,8 +47,9 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
#else #else
0); 0);
#endif #endif
/* the rest of these check to see if the valid field has the appropriate /* The rest of these check to see if the valid field has the appropriate
flag set, and if it does, writes the chunk. */ * flag set, and if it does, writes the chunk.
*/
#if defined(PNG_WRITE_gAMA_SUPPORTED) #if defined(PNG_WRITE_gAMA_SUPPORTED)
if (info_ptr->valid & PNG_INFO_gAMA) if (info_ptr->valid & PNG_INFO_gAMA)
{ {
@ -147,7 +148,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_tRNS) if (info_ptr->valid & PNG_INFO_tRNS)
{ {
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel (in tRNS) */ /* Invert the alpha channel (in tRNS) */
if ((png_ptr->transformations & PNG_INVERT_ALPHA) && if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
{ {
@ -202,30 +203,33 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
#endif #endif /* pHYs */
#if defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_WRITE_tIME_SUPPORTED)
if (info_ptr->valid & PNG_INFO_tIME) if (info_ptr->valid & PNG_INFO_tIME)
{ {
png_write_tIME(png_ptr, &(info_ptr->mod_time)); png_write_tIME(png_ptr, &(info_ptr->mod_time));
png_ptr->mode |= PNG_WROTE_tIME; png_ptr->mode |= PNG_WROTE_tIME;
} }
#endif #endif /* tIME */
#if defined(PNG_WRITE_sPLT_SUPPORTED) #if defined(PNG_WRITE_sPLT_SUPPORTED)
if (info_ptr->valid & PNG_INFO_sPLT) if (info_ptr->valid & PNG_INFO_sPLT)
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
#endif #endif /* sPLT */
#if defined(PNG_WRITE_TEXT_SUPPORTED) #if defined(PNG_WRITE_TEXT_SUPPORTED)
/* Check to see if we need to write text chunks */ /* Check to see if we need to write text chunks */
for (i = 0; i < info_ptr->num_text; i++) for (i = 0; i < info_ptr->num_text; i++)
{ {
png_debug2(2, "Writing header text chunk %d, type %d", i, png_debug2(2, "Writing header text chunk %d, type %d", i,
info_ptr->text[i].compression); info_ptr->text[i].compression);
/* an internationalized chunk? */ /* An internationalized chunk? */
if (info_ptr->text[i].compression > 0) if (info_ptr->text[i].compression > 0)
{ {
#if defined(PNG_WRITE_iTXt_SUPPORTED) #if defined(PNG_WRITE_iTXt_SUPPORTED)
/* write international chunk */ /* Write international chunk */
png_write_iTXt(png_ptr, png_write_iTXt(png_ptr,
info_ptr->text[i].compression, info_ptr->text[i].compression,
info_ptr->text[i].key, info_ptr->text[i].key,
@ -242,7 +246,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
{ {
#if defined(PNG_WRITE_zTXt_SUPPORTED) #if defined(PNG_WRITE_zTXt_SUPPORTED)
/* write compressed chunk */ /* Write compressed chunk */
png_write_zTXt(png_ptr, info_ptr->text[i].key, png_write_zTXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, 0, info_ptr->text[i].text, 0,
info_ptr->text[i].compression); info_ptr->text[i].compression);
@ -255,18 +259,20 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
{ {
#if defined(PNG_WRITE_tEXt_SUPPORTED) #if defined(PNG_WRITE_tEXt_SUPPORTED)
/* write uncompressed chunk */ /* Write uncompressed chunk */
png_write_tEXt(png_ptr, info_ptr->text[i].key, png_write_tEXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, info_ptr->text[i].text,
0); 0);
#else
png_warning(png_ptr, "Unable to write uncompressed text");
#endif
/* Mark this chunk as written */ /* Mark this chunk as written */
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
} #else
} /* Can't get here */
png_warning(png_ptr, "Unable to write uncompressed text");
#endif #endif
}
}
#endif /* tEXt */
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
if (info_ptr->unknown_chunks_num) if (info_ptr->unknown_chunks_num)
{ {
@ -306,29 +312,29 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
if (!(png_ptr->mode & PNG_HAVE_IDAT)) if (!(png_ptr->mode & PNG_HAVE_IDAT))
png_error(png_ptr, "No IDATs written into file"); png_error(png_ptr, "No IDATs written into file");
/* see if user wants us to write information chunks */ /* See if user wants us to write information chunks */
if (info_ptr != NULL) if (info_ptr != NULL)
{ {
#if defined(PNG_WRITE_TEXT_SUPPORTED) #if defined(PNG_WRITE_TEXT_SUPPORTED)
int i; /* local index variable */ int i; /* Local index variable */
#endif #endif
#if defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_WRITE_tIME_SUPPORTED)
/* check to see if user has supplied a time chunk */ /* Check to see if user has supplied a time chunk */
if ((info_ptr->valid & PNG_INFO_tIME) && if ((info_ptr->valid & PNG_INFO_tIME) &&
!(png_ptr->mode & PNG_WROTE_tIME)) !(png_ptr->mode & PNG_WROTE_tIME))
png_write_tIME(png_ptr, &(info_ptr->mod_time)); png_write_tIME(png_ptr, &(info_ptr->mod_time));
#endif #endif
#if defined(PNG_WRITE_TEXT_SUPPORTED) #if defined(PNG_WRITE_TEXT_SUPPORTED)
/* loop through comment chunks */ /* Loop through comment chunks */
for (i = 0; i < info_ptr->num_text; i++) for (i = 0; i < info_ptr->num_text; i++)
{ {
png_debug2(2, "Writing trailer text chunk %d, type %d", i, png_debug2(2, "Writing trailer text chunk %d, type %d", i,
info_ptr->text[i].compression); info_ptr->text[i].compression);
/* an internationalized chunk? */ /* An internationalized chunk? */
if (info_ptr->text[i].compression > 0) if (info_ptr->text[i].compression > 0)
{ {
#if defined(PNG_WRITE_iTXt_SUPPORTED) #if defined(PNG_WRITE_iTXt_SUPPORTED)
/* write international chunk */ /* Write international chunk */
png_write_iTXt(png_ptr, png_write_iTXt(png_ptr,
info_ptr->text[i].compression, info_ptr->text[i].compression,
info_ptr->text[i].key, info_ptr->text[i].key,
@ -344,7 +350,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
{ {
#if defined(PNG_WRITE_zTXt_SUPPORTED) #if defined(PNG_WRITE_zTXt_SUPPORTED)
/* write compressed chunk */ /* Write compressed chunk */
png_write_zTXt(png_ptr, info_ptr->text[i].key, png_write_zTXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, 0, info_ptr->text[i].text, 0,
info_ptr->text[i].compression); info_ptr->text[i].compression);
@ -357,7 +363,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
{ {
#if defined(PNG_WRITE_tEXt_SUPPORTED) #if defined(PNG_WRITE_tEXt_SUPPORTED)
/* write uncompressed chunk */ /* Write uncompressed chunk */
png_write_tEXt(png_ptr, info_ptr->text[i].key, png_write_tEXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, 0); info_ptr->text[i].text, 0);
#else #else
@ -395,7 +401,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
/* write end of PNG file */ /* Write end of PNG file */
png_write_IEND(png_ptr); png_write_IEND(png_ptr);
/* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03, /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
* and restored again in libpng-1.2.30, may cause some applications that * and restored again in libpng-1.2.30, may cause some applications that
@ -475,7 +481,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
if (png_ptr == NULL) if (png_ptr == NULL)
return (NULL); return (NULL);
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
@ -546,7 +552,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
} }
} }
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@ -640,7 +646,7 @@ png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
{ {
png_structp png_ptr=*ptr_ptr; png_structp png_ptr=*ptr_ptr;
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
jmp_buf tmp_jmp; /* to save current jump buffer */ jmp_buf tmp_jmp; /* To save current jump buffer */
#endif #endif
int i = 0; int i = 0;
@ -666,7 +672,7 @@ png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
png_debug(1, "in png_write_init_3"); png_debug(1, "in png_write_init_3");
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* save jump buffer and error functions */ /* Save jump buffer and error functions */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
#endif #endif
@ -677,24 +683,24 @@ png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
*ptr_ptr = png_ptr; *ptr_ptr = png_ptr;
} }
/* reset all variables to 0 */ /* Reset all variables to 0 */
png_memset(png_ptr, 0, png_sizeof(png_struct)); png_memset(png_ptr, 0, png_sizeof(png_struct));
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
#endif #endif
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* restore jump buffer */ /* Restore jump buffer */
png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
#endif #endif
png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
png_flush_ptr_NULL); png_flush_ptr_NULL);
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@ -714,15 +720,15 @@ void PNGAPI
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)
{ {
png_uint_32 i; /* row counter */ png_uint_32 i; /* Row counter */
png_bytepp rp; /* row pointer */ png_bytepp rp; /* Row pointer */
png_debug(1, "in png_write_rows"); png_debug(1, "in png_write_rows");
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
/* loop through the rows */ /* Loop through the rows */
for (i = 0, rp = row; i < num_rows; i++, rp++) for (i = 0, rp = row; i < num_rows; i++, rp++)
{ {
png_write_row(png_ptr, *rp); png_write_row(png_ptr, *rp);
@ -735,25 +741,26 @@ png_write_rows(png_structp png_ptr, png_bytepp row,
void PNGAPI void PNGAPI
png_write_image(png_structp png_ptr, png_bytepp image) png_write_image(png_structp png_ptr, png_bytepp image)
{ {
png_uint_32 i; /* row index */ png_uint_32 i; /* Row index */
int pass, num_pass; /* pass variables */ int pass, num_pass; /* Pass variables */
png_bytepp rp; /* points to current row */ png_bytepp rp; /* Points to current row */
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
png_debug(1, "in png_write_image"); png_debug(1, "in png_write_image");
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* intialize interlace handling. If image is not interlaced, /* Initialize interlace handling. If image is not interlaced,
this will set pass to 1 */ * this will set pass to 1
*/
num_pass = png_set_interlace_handling(png_ptr); num_pass = png_set_interlace_handling(png_ptr);
#else #else
num_pass = 1; num_pass = 1;
#endif #endif
/* loop through passes */ /* Loop through passes */
for (pass = 0; pass < num_pass; pass++) for (pass = 0; pass < num_pass; pass++)
{ {
/* loop through image */ /* Loop through image */
for (i = 0, rp = image; i < png_ptr->height; i++, rp++) for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
{ {
png_write_row(png_ptr, *rp); png_write_row(png_ptr, *rp);
@ -761,7 +768,7 @@ png_write_image(png_structp png_ptr, png_bytepp image)
} }
} }
/* called by user to write a row of image data */ /* Called by user to write a row of image data */
void PNGAPI void PNGAPI
png_write_row(png_structp png_ptr, png_bytep row) png_write_row(png_structp png_ptr, png_bytep row)
{ {
@ -770,15 +777,15 @@ png_write_row(png_structp png_ptr, png_bytep row)
png_debug2(1, "in png_write_row (row %ld, pass %d)", png_debug2(1, "in png_write_row (row %ld, pass %d)",
png_ptr->row_number, png_ptr->pass); 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)
{ {
/* make sure we wrote the header info */ /* Make sure we wrote the header info */
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
png_error(png_ptr, png_error(png_ptr,
"png_write_info was never called before png_write_row."); "png_write_info was never called before png_write_row.");
/* check for transforms that have been set but were defined out */ /* Check for transforms that have been set but were defined out */
#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
if (png_ptr->transformations & PNG_INVERT_MONO) if (png_ptr->transformations & PNG_INVERT_MONO)
png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");
@ -812,7 +819,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
} }
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* if interlaced and not interested in row, return */ /* If interlaced and not interested in row, return */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
{ {
switch (png_ptr->pass) switch (png_ptr->pass)
@ -870,7 +877,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
} }
#endif #endif
/* set up row info for transformations */ /* Set up row info for transformations */
png_ptr->row_info.color_type = png_ptr->color_type; png_ptr->row_info.color_type = png_ptr->color_type;
png_ptr->row_info.width = png_ptr->usr_width; png_ptr->row_info.width = png_ptr->usr_width;
png_ptr->row_info.channels = png_ptr->usr_channels; png_ptr->row_info.channels = png_ptr->usr_channels;
@ -893,13 +900,13 @@ png_write_row(png_structp png_ptr, png_bytep row)
png_ptr->row_info.rowbytes); png_ptr->row_info.rowbytes);
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* handle interlacing */ /* Handle interlacing */
if (png_ptr->interlaced && png_ptr->pass < 6 && if (png_ptr->interlaced && png_ptr->pass < 6 &&
(png_ptr->transformations & PNG_INTERLACE)) (png_ptr->transformations & PNG_INTERLACE))
{ {
png_do_write_interlace(&(png_ptr->row_info), png_do_write_interlace(&(png_ptr->row_info),
png_ptr->row_buf + 1, png_ptr->pass); png_ptr->row_buf + 1, png_ptr->pass);
/* this should always get caught above, but still ... */ /* This should always get caught above, but still ... */
if (!(png_ptr->row_info.width)) if (!(png_ptr->row_info.width))
{ {
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
@ -908,7 +915,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
} }
#endif #endif
/* handle other transformations */ /* Handle other transformations */
if (png_ptr->transformations) if (png_ptr->transformations)
png_do_write_transformations(png_ptr); png_do_write_transformations(png_ptr);
@ -948,7 +955,7 @@ png_set_flush(png_structp png_ptr, int nrows)
png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
} }
/* flush the current output buffers now */ /* Flush the current output buffers now */
void PNGAPI void PNGAPI
png_write_flush(png_structp png_ptr) png_write_flush(png_structp png_ptr)
{ {
@ -965,11 +972,11 @@ png_write_flush(png_structp png_ptr)
{ {
int ret; int ret;
/* compress the data */ /* Compress the data */
ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
wrote_IDAT = 0; wrote_IDAT = 0;
/* check for compression errors */ /* Check for compression errors */
if (ret != Z_OK) if (ret != Z_OK)
{ {
if (png_ptr->zstream.msg != NULL) if (png_ptr->zstream.msg != NULL)
@ -980,7 +987,7 @@ png_write_flush(png_structp png_ptr)
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
/* write the IDAT and reset the zlib output buffer */ /* Write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf, png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size); png_ptr->zbuf_size);
png_ptr->zstream.next_out = png_ptr->zbuf; png_ptr->zstream.next_out = png_ptr->zbuf;
@ -992,7 +999,7 @@ png_write_flush(png_structp png_ptr)
/* If there is any data left to be output, write it into a new IDAT */ /* If there is any data left to be output, write it into a new IDAT */
if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
{ {
/* write the IDAT and reset the zlib output buffer */ /* Write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf, png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
png_ptr->zstream.next_out = png_ptr->zbuf; png_ptr->zstream.next_out = png_ptr->zbuf;
@ -1003,7 +1010,7 @@ png_write_flush(png_structp png_ptr)
} }
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ #endif /* PNG_WRITE_FLUSH_SUPPORTED */
/* free all memory used by the write */ /* Free all memory used by the write */
void PNGAPI void PNGAPI
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
{ {
@ -1079,7 +1086,7 @@ void /* PRIVATE */
png_write_destroy(png_structp png_ptr) png_write_destroy(png_structp png_ptr)
{ {
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
jmp_buf tmp_jmp; /* save jump buffer */ jmp_buf tmp_jmp; /* Save jump buffer */
#endif #endif
png_error_ptr error_fn; png_error_ptr error_fn;
png_error_ptr warning_fn; png_error_ptr warning_fn;
@ -1089,10 +1096,10 @@ png_write_destroy(png_structp png_ptr)
#endif #endif
png_debug(1, "in png_write_destroy"); png_debug(1, "in png_write_destroy");
/* free any memory zlib uses */ /* Free any memory zlib uses */
deflateEnd(&png_ptr->zstream); deflateEnd(&png_ptr->zstream);
/* free our memory. png_free checks NULL for us. */ /* Free our memory. png_free checks NULL for us. */
png_free(png_ptr, png_ptr->zbuf); png_free(png_ptr, png_ptr->zbuf);
png_free(png_ptr, png_ptr->row_buf); png_free(png_ptr, png_ptr->row_buf);
#ifndef PNG_NO_WRITE_FILTER #ifndef PNG_NO_WRITE_FILTER
@ -1116,7 +1123,7 @@ png_write_destroy(png_structp png_ptr)
#endif #endif
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* reset structure */ /* Reset structure */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
#endif #endif
@ -1419,7 +1426,7 @@ png_set_compression_window_bits(png_structp png_ptr, int window_bits)
else if (window_bits < 8) else if (window_bits < 8)
png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
#ifndef WBITS_8_OK #ifndef WBITS_8_OK
/* avoid libpng bug with 256-byte windows */ /* Avoid libpng bug with 256-byte windows */
if (window_bits == 8) if (window_bits == 8)
{ {
png_warning(png_ptr, "Compression window is being reset to 512"); png_warning(png_ptr, "Compression window is being reset to 512");
@ -1472,7 +1479,7 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel from opacity to transparency */ /* Invert the alpha channel from opacity to transparency */
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
png_set_invert_alpha(png_ptr); png_set_invert_alpha(png_ptr);
#endif #endif
@ -1483,7 +1490,7 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
/* ------ these transformations don't touch the info structure ------- */ /* ------ these transformations don't touch the info structure ------- */
#if defined(PNG_WRITE_INVERT_SUPPORTED) #if defined(PNG_WRITE_INVERT_SUPPORTED)
/* invert monochrome pixels */ /* Invert monochrome pixels */
if (transforms & PNG_TRANSFORM_INVERT_MONO) if (transforms & PNG_TRANSFORM_INVERT_MONO)
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
#endif #endif
@ -1498,13 +1505,13 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
#endif #endif
#if defined(PNG_WRITE_PACK_SUPPORTED) #if defined(PNG_WRITE_PACK_SUPPORTED)
/* pack pixels into bytes */ /* Pack pixels into bytes */
if (transforms & PNG_TRANSFORM_PACKING) if (transforms & PNG_TRANSFORM_PACKING)
png_set_packing(png_ptr); png_set_packing(png_ptr);
#endif #endif
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
/* swap location of alpha bytes from ARGB to RGBA */ /* Swap location of alpha bytes from ARGB to RGBA */
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
#endif #endif
@ -1518,33 +1525,33 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
#endif #endif
#if defined(PNG_WRITE_BGR_SUPPORTED) #if defined(PNG_WRITE_BGR_SUPPORTED)
/* flip BGR pixels to RGB */ /* Flip BGR pixels to RGB */
if (transforms & PNG_TRANSFORM_BGR) if (transforms & PNG_TRANSFORM_BGR)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
#endif #endif
#if defined(PNG_WRITE_SWAP_SUPPORTED) #if defined(PNG_WRITE_SWAP_SUPPORTED)
/* swap bytes of 16-bit files to most significant byte first */ /* Swap bytes of 16-bit files to most significant byte first */
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
png_set_swap(png_ptr); png_set_swap(png_ptr);
#endif #endif
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) #if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
/* swap bits of 1, 2, 4 bit packed pixel formats */ /* Swap bits of 1, 2, 4 bit packed pixel formats */
if (transforms & PNG_TRANSFORM_PACKSWAP) if (transforms & PNG_TRANSFORM_PACKSWAP)
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
#endif #endif
/* ----------------------- end of transformations ------------------- */ /* ----------------------- end of transformations ------------------- */
/* write the bits */ /* Write the bits */
if (info_ptr->valid & PNG_INFO_IDAT) if (info_ptr->valid & PNG_INFO_IDAT)
png_write_image(png_ptr, info_ptr->row_pointers); png_write_image(png_ptr, info_ptr->row_pointers);
/* It is REQUIRED to call this to finish writing the rest of the file */ /* It is REQUIRED to call this to finish writing the rest of the file */
png_write_end(png_ptr, info_ptr); png_write_end(png_ptr, info_ptr);
transforms = transforms; /* quiet compiler warnings */ transforms = transforms; /* Quiet compiler warnings */
params = params; params = params;
} }
#endif #endif

16
pngwtran.c
View File

@ -1,9 +1,9 @@
/* pngwtran.c - transforms the data in a row for PNG writers /* pngwtran.c - transforms the data in a row for PNG writers
* *
* Last changed in libpng 1.2.9 April 14, 2006 * Last changed in libpng 1.2.37 [May 20, 2009]
* 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) 1998-2006 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@ -26,7 +26,7 @@ png_do_write_transformations(png_structp png_ptr)
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
if (png_ptr->transformations & PNG_USER_TRANSFORM) if (png_ptr->transformations & PNG_USER_TRANSFORM)
if (png_ptr->write_user_transform_fn != NULL) if (png_ptr->write_user_transform_fn != NULL)
(*(png_ptr->write_user_transform_fn)) /* user write transform function */ (*(png_ptr->write_user_transform_fn)) /* User write transform function */
(png_ptr, /* png_ptr */ (png_ptr, /* png_ptr */
&(png_ptr->row_info), /* row_info: */ &(png_ptr->row_info), /* row_info: */
/* png_uint_32 width; width of row */ /* png_uint_32 width; width of row */
@ -248,7 +248,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
channels++; channels++;
} }
/* with low row depths, could only be grayscale, so one channel */ /* With low row depths, could only be grayscale, so one channel */
if (row_info->bit_depth < 8) if (row_info->bit_depth < 8)
{ {
png_bytep bp = row; png_bytep bp = row;
@ -439,7 +439,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
png_uint_32 row_width = row_info->width; png_uint_32 row_width = row_info->width;
for (i = 0, sp = dp = row; i < row_width; i++) for (i = 0, sp = dp = row; i < row_width; i++)
{ {
/* does nothing /* Does nothing
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
@ -457,7 +457,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0, sp = dp = row; i < row_width; i++) for (i = 0, sp = dp = row; i < row_width; i++)
{ {
/* does nothing /* Does nothing
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
@ -495,7 +495,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0, sp = dp = row; i < row_width; i++) for (i = 0, sp = dp = row; i < row_width; i++)
{ {
/* does nothing /* Does nothing
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
*/ */
@ -510,7 +510,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
#endif #endif
#if defined(PNG_MNG_FEATURES_SUPPORTED) #if defined(PNG_MNG_FEATURES_SUPPORTED)
/* undoes intrapixel differencing */ /* Undoes intrapixel differencing */
void /* PRIVATE */ void /* PRIVATE */
png_do_write_intrapixel(png_row_infop row_info, png_bytep row) png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
{ {

296
pngwutil.c
View File

@ -1,7 +1,7 @@
/* pngwutil.c - utilities to write a PNG file /* pngwutil.c - utilities to write a PNG file
* *
* Last changed in libpng 1.2.36 [May 7, 2009] * Last changed in libpng 1.2.36 [May 20, 2009]
* 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) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -60,7 +60,7 @@ png_write_sig(png_structp png_ptr)
{ {
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
/* write the rest of the 8 byte signature */ /* Write the rest of the 8 byte signature */
png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
(png_size_t)(8 - png_ptr->sig_bytes)); (png_size_t)(8 - png_ptr->sig_bytes));
if (png_ptr->sig_bytes < 3) if (png_ptr->sig_bytes < 3)
@ -80,7 +80,8 @@ void PNGAPI
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)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);
png_write_chunk_data(png_ptr, data, (png_size_t)length); png_write_chunk_data(png_ptr, data, (png_size_t)length);
png_write_chunk_end(png_ptr); png_write_chunk_end(png_ptr);
@ -98,15 +99,16 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
png_debug2(0, "Writing %s chunk, length = %lu", chunk_name, png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,
(unsigned long)length); (unsigned long)length);
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
/* write the length and the chunk name */ /* Write the length and the chunk name */
png_save_uint_32(buf, length); png_save_uint_32(buf, length);
png_memcpy(buf + 4, chunk_name, 4); png_memcpy(buf + 4, chunk_name, 4);
png_write_data(png_ptr, buf, (png_size_t)8); png_write_data(png_ptr, buf, (png_size_t)8);
/* put the chunk name into png_ptr->chunk_name */ /* Put the chunk name into png_ptr->chunk_name */
png_memcpy(png_ptr->chunk_name, chunk_name, 4); png_memcpy(png_ptr->chunk_name, chunk_name, 4);
/* reset the crc and run it over the chunk name */ /* Reset the crc and run it over the chunk name */
png_reset_crc(png_ptr); png_reset_crc(png_ptr);
png_calculate_crc(png_ptr, chunk_name, (png_size_t)4); png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);
} }
@ -119,12 +121,13 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
void PNGAPI void PNGAPI
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)
{ {
/* write the data, and run the CRC over it */ /* Write the data, and run the CRC over it */
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (data != NULL && length > 0) if (data != NULL && length > 0)
{ {
png_write_data(png_ptr, data, length); png_write_data(png_ptr, data, length);
/* update the CRC after writing the data, /* Update the CRC after writing the data,
* in case that the user I/O routine alters it. * in case that the user I/O routine alters it.
*/ */
png_calculate_crc(png_ptr, data, length); png_calculate_crc(png_ptr, data, length);
@ -139,15 +142,14 @@ png_write_chunk_end(png_structp png_ptr)
if (png_ptr == NULL) return; if (png_ptr == NULL) return;
/* write the crc in a single operation */ /* Write the crc in a single operation */
png_save_uint_32(buf, png_ptr->crc); png_save_uint_32(buf, png_ptr->crc);
png_write_data(png_ptr, buf, (png_size_t)4); png_write_data(png_ptr, buf, (png_size_t)4);
} }
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED) #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)
/* /* This pair of functions encapsulates the operation of (a) compressing a
* This pair of functions encapsulates the operation of (a) compressing a
* text string, and (b) issuing it later as a series of chunk data writes. * text string, and (b) issuing it later as a series of chunk data writes.
* The compression_state structure is shared context for these functions * The compression_state structure is shared context for these functions
* set up by the caller in order to make the whole mess thread-safe. * set up by the caller in order to make the whole mess thread-safe.
@ -155,14 +157,14 @@ png_write_chunk_end(png_structp png_ptr)
typedef struct typedef struct
{ {
char *input; /* the uncompressed input data */ char *input; /* The uncompressed input data */
int input_len; /* its length */ int input_len; /* Its length */
int num_output_ptr; /* number of output pointers used */ int num_output_ptr; /* Number of output pointers used */
int max_output_ptr; /* size of output_ptr */ int max_output_ptr; /* Size of output_ptr */
png_charpp output_ptr; /* array of pointers to output */ png_charpp output_ptr; /* Array of pointers to output */
} compression_state; } compression_state;
/* compress given text into storage in the png_ptr structure */ /* Compress given text into storage in the png_ptr structure */
static int /* PRIVATE */ static int /* PRIVATE */
png_text_compress(png_structp png_ptr, png_text_compress(png_structp png_ptr,
png_charp text, png_size_t text_len, int compression, png_charp text, png_size_t text_len, int compression,
@ -176,7 +178,7 @@ png_text_compress(png_structp png_ptr,
comp->input = NULL; comp->input = NULL;
comp->input_len = 0; comp->input_len = 0;
/* we may just want to pass the text right through */ /* We may just want to pass the text right through */
if (compression == PNG_TEXT_COMPRESSION_NONE) if (compression == PNG_TEXT_COMPRESSION_NONE)
{ {
comp->input = text; comp->input = text;
@ -210,29 +212,29 @@ png_text_compress(png_structp png_ptr,
* wouldn't cause a failure, just a slowdown due to swapping). * wouldn't cause a failure, just a slowdown due to swapping).
*/ */
/* set up the compression buffers */ /* Set up the compression buffers */
png_ptr->zstream.avail_in = (uInt)text_len; png_ptr->zstream.avail_in = (uInt)text_len;
png_ptr->zstream.next_in = (Bytef *)text; png_ptr->zstream.next_in = (Bytef *)text;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf; png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;
/* this is the same compression loop as in png_write_row() */ /* This is the same compression loop as in png_write_row() */
do do
{ {
/* compress the data */ /* Compress the data */
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
if (ret != Z_OK) if (ret != Z_OK)
{ {
/* error */ /* Error */
if (png_ptr->zstream.msg != NULL) if (png_ptr->zstream.msg != NULL)
png_error(png_ptr, png_ptr->zstream.msg); png_error(png_ptr, png_ptr->zstream.msg);
else else
png_error(png_ptr, "zlib error"); png_error(png_ptr, "zlib error");
} }
/* check to see if we need more room */ /* Check to see if we need more room */
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
/* make sure the output array has room */ /* Make sure the output array has room */
if (comp->num_output_ptr >= comp->max_output_ptr) if (comp->num_output_ptr >= comp->max_output_ptr)
{ {
int old_max; int old_max;
@ -257,7 +259,7 @@ png_text_compress(png_structp png_ptr,
(comp->max_output_ptr * png_sizeof(png_charp))); (comp->max_output_ptr * png_sizeof(png_charp)));
} }
/* save the data */ /* Save the data */
comp->output_ptr[comp->num_output_ptr] = comp->output_ptr[comp->num_output_ptr] =
(png_charp)png_malloc(png_ptr, (png_charp)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@ -269,21 +271,21 @@ png_text_compress(png_structp png_ptr,
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
png_ptr->zstream.next_out = png_ptr->zbuf; png_ptr->zstream.next_out = png_ptr->zbuf;
} }
/* continue until we don't have any more to compress */ /* Continue until we don't have any more to compress */
} while (png_ptr->zstream.avail_in); } while (png_ptr->zstream.avail_in);
/* finish the compression */ /* Finish the compression */
do do
{ {
/* tell zlib we are finished */ /* Tell zlib we are finished */
ret = deflate(&png_ptr->zstream, Z_FINISH); ret = deflate(&png_ptr->zstream, Z_FINISH);
if (ret == Z_OK) if (ret == Z_OK)
{ {
/* check to see if we need more room */ /* Check to see if we need more room */
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
/* check to make sure our output array has room */ /* Check to make sure our output array has room */
if (comp->num_output_ptr >= comp->max_output_ptr) if (comp->num_output_ptr >= comp->max_output_ptr)
{ {
int old_max; int old_max;
@ -309,7 +311,7 @@ png_text_compress(png_structp png_ptr,
png_sizeof(png_charp))); png_sizeof(png_charp)));
} }
/* save off the data */ /* Save the data */
comp->output_ptr[comp->num_output_ptr] = comp->output_ptr[comp->num_output_ptr] =
(png_charp)png_malloc(png_ptr, (png_charp)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@ -324,7 +326,7 @@ png_text_compress(png_structp png_ptr,
} }
else if (ret != Z_STREAM_END) else if (ret != Z_STREAM_END)
{ {
/* we got an error */ /* We got an error */
if (png_ptr->zstream.msg != NULL) if (png_ptr->zstream.msg != NULL)
png_error(png_ptr, png_ptr->zstream.msg); png_error(png_ptr, png_ptr->zstream.msg);
else else
@ -332,7 +334,7 @@ png_text_compress(png_structp png_ptr,
} }
} while (ret != Z_STREAM_END); } while (ret != Z_STREAM_END);
/* text length is number of buffers plus last buffer */ /* Text length is number of buffers plus last buffer */
text_len = png_ptr->zbuf_size * comp->num_output_ptr; text_len = png_ptr->zbuf_size * comp->num_output_ptr;
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out; text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;
@ -340,13 +342,13 @@ png_text_compress(png_structp png_ptr,
return((int)text_len); return((int)text_len);
} }
/* ship the compressed text out via chunk writes */ /* Ship the compressed text out via chunk writes */
static void /* PRIVATE */ static void /* PRIVATE */
png_write_compressed_data_out(png_structp png_ptr, compression_state *comp) png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
{ {
int i; int i;
/* handle the no-compression case */ /* Handle the no-compression case */
if (comp->input) if (comp->input)
{ {
png_write_chunk_data(png_ptr, (png_bytep)comp->input, png_write_chunk_data(png_ptr, (png_bytep)comp->input,
@ -354,7 +356,7 @@ png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
return; return;
} }
/* write saved output buffers, if any */ /* Write saved output buffers, if any */
for (i = 0; i < comp->num_output_ptr; i++) for (i = 0; i < comp->num_output_ptr; i++)
{ {
png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i], png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],
@ -365,12 +367,12 @@ png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
if (comp->max_output_ptr != 0) if (comp->max_output_ptr != 0)
png_free(png_ptr, comp->output_ptr); png_free(png_ptr, comp->output_ptr);
comp->output_ptr=NULL; comp->output_ptr=NULL;
/* write anything left in zbuf */ /* Write anything left in zbuf */
if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
png_write_chunk_data(png_ptr, png_ptr->zbuf, png_write_chunk_data(png_ptr, png_ptr->zbuf,
(png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out)); (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));
/* reset zlib for another zTXt/iTXt or image data */ /* Reset zlib for another zTXt/iTXt or image data */
deflateReset(&png_ptr->zstream); deflateReset(&png_ptr->zstream);
png_ptr->zstream.data_type = Z_BINARY; png_ptr->zstream.data_type = Z_BINARY;
} }
@ -390,7 +392,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
#endif #endif
int ret; int ret;
png_byte buf[13]; /* buffer to store the IHDR info */ png_byte buf[13]; /* Buffer to store the IHDR info */
png_debug(1, "in png_write_IHDR"); png_debug(1, "in png_write_IHDR");
/* Check that we have valid input data from the application info */ /* Check that we have valid input data from the application info */
@ -476,7 +478,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
interlace_type=PNG_INTERLACE_NONE; interlace_type=PNG_INTERLACE_NONE;
#endif #endif
/* save off the relevent information */ /* Save the relevent information */
png_ptr->bit_depth = (png_byte)bit_depth; png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr->color_type = (png_byte)color_type; png_ptr->color_type = (png_byte)color_type;
png_ptr->interlaced = (png_byte)interlace_type; png_ptr->interlaced = (png_byte)interlace_type;
@ -489,12 +491,12 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width); png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
/* set the usr info, so any transformations can modify it */ /* Set the usr info, so any transformations can modify it */
png_ptr->usr_width = png_ptr->width; png_ptr->usr_width = png_ptr->width;
png_ptr->usr_bit_depth = png_ptr->bit_depth; png_ptr->usr_bit_depth = png_ptr->bit_depth;
png_ptr->usr_channels = png_ptr->channels; png_ptr->usr_channels = png_ptr->channels;
/* pack the header information into the buffer */ /* Pack the header information into the buffer */
png_save_uint_32(buf, width); png_save_uint_32(buf, width);
png_save_uint_32(buf + 4, height); png_save_uint_32(buf + 4, height);
buf[8] = (png_byte)bit_depth; buf[8] = (png_byte)bit_depth;
@ -503,10 +505,10 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
buf[11] = (png_byte)filter_type; buf[11] = (png_byte)filter_type;
buf[12] = (png_byte)interlace_type; buf[12] = (png_byte)interlace_type;
/* write the chunk */ /* Write the chunk */
png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13); png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
/* initialize zlib with PNG info */ /* Initialize zlib with PNG info */
png_ptr->zstream.zalloc = png_zalloc; png_ptr->zstream.zalloc = png_zalloc;
png_ptr->zstream.zfree = png_zfree; png_ptr->zstream.zfree = png_zfree;
png_ptr->zstream.opaque = (voidpf)png_ptr; png_ptr->zstream.opaque = (voidpf)png_ptr;
@ -549,13 +551,13 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
png_ptr->zstream.next_out = png_ptr->zbuf; png_ptr->zstream.next_out = png_ptr->zbuf;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
/* libpng is not interested in zstream.data_type */ /* libpng is not interested in zstream.data_type */
/* set it to a predefined value, to avoid its evaluation inside zlib */ /* Set it to a predefined value, to avoid its evaluation inside zlib */
png_ptr->zstream.data_type = Z_BINARY; png_ptr->zstream.data_type = Z_BINARY;
png_ptr->mode = PNG_HAVE_IHDR; png_ptr->mode = PNG_HAVE_IHDR;
} }
/* 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 convenient * correct order for PNG, so people can redefine it to any convenient
* structure. * structure.
*/ */
@ -622,7 +624,7 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
png_ptr->mode |= PNG_HAVE_PLTE; png_ptr->mode |= PNG_HAVE_PLTE;
} }
/* write an IDAT chunk */ /* Write an IDAT chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
@ -639,9 +641,11 @@ png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
unsigned int z_cmf = data[0]; /* zlib compression method and flags */ unsigned int z_cmf = data[0]; /* zlib compression method and flags */
if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
{ {
/* Avoid memory underflows and multiplication overflows. */ /* Avoid memory underflows and multiplication overflows.
/* The conditions below are practically always satisfied; *
however, they still must be checked. */ * The conditions below are practically always satisfied;
* however, they still must be checked.
*/
if (length >= 2 && if (length >= 2 &&
png_ptr->height < 16384 && png_ptr->width < 16384) png_ptr->height < 16384 && png_ptr->width < 16384)
{ {
@ -674,7 +678,7 @@ png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
png_ptr->mode |= PNG_HAVE_IDAT; png_ptr->mode |= PNG_HAVE_IDAT;
} }
/* write an IEND chunk */ /* Write an IEND chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_IEND(png_structp png_ptr) png_write_IEND(png_structp png_ptr)
{ {
@ -688,7 +692,7 @@ png_write_IEND(png_structp png_ptr)
} }
#if defined(PNG_WRITE_gAMA_SUPPORTED) #if defined(PNG_WRITE_gAMA_SUPPORTED)
/* write a gAMA chunk */ /* Write a gAMA chunk */
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_write_gAMA(png_structp png_ptr, double file_gamma) png_write_gAMA(png_structp png_ptr, double file_gamma)
@ -724,7 +728,7 @@ png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
#endif #endif
#if defined(PNG_WRITE_sRGB_SUPPORTED) #if defined(PNG_WRITE_sRGB_SUPPORTED)
/* write a sRGB chunk */ /* Write a sRGB chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_sRGB(png_structp png_ptr, int srgb_intent) png_write_sRGB(png_structp png_ptr, int srgb_intent)
{ {
@ -743,7 +747,7 @@ png_write_sRGB(png_structp png_ptr, int srgb_intent)
#endif #endif
#if defined(PNG_WRITE_iCCP_SUPPORTED) #if defined(PNG_WRITE_iCCP_SUPPORTED)
/* write an iCCP chunk */ /* Write an iCCP chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type, png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
png_charp profile, int profile_len) png_charp profile, int profile_len)
@ -800,7 +804,7 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
profile_len = png_text_compress(png_ptr, profile, profile_len = png_text_compress(png_ptr, profile,
(png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp); (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
/* make sure we include the NULL after the name and the compression type */ /* Make sure we include the NULL after the name and the compression type */
png_write_chunk_start(png_ptr, (png_bytep)png_iCCP, png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,
(png_uint_32)(name_len + profile_len + 2)); (png_uint_32)(name_len + profile_len + 2));
new_name[name_len + 1] = 0x00; new_name[name_len + 1] = 0x00;
@ -816,7 +820,7 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
#endif #endif
#if defined(PNG_WRITE_sPLT_SUPPORTED) #if defined(PNG_WRITE_sPLT_SUPPORTED)
/* write a sPLT chunk */ /* Write a sPLT chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
{ {
@ -834,18 +838,17 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
#endif #endif
png_debug(1, "in png_write_sPLT"); png_debug(1, "in png_write_sPLT");
if ((name_len = png_check_keyword(png_ptr, if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0)
spalette->name, &new_name))==0)
return; return;
/* make sure we include the NULL after the name */ /* Make sure we include the NULL after the name */
png_write_chunk_start(png_ptr, (png_bytep)png_sPLT, png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,
(png_uint_32)(name_len + 2 + palette_size)); (png_uint_32)(name_len + 2 + palette_size));
png_write_chunk_data(png_ptr, (png_bytep)new_name, png_write_chunk_data(png_ptr, (png_bytep)new_name,
(png_size_t)(name_len + 1)); (png_size_t)(name_len + 1));
png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1); png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);
/* loop through each palette entry, writing appropriately */ /* Loop through each palette entry, writing appropriately */
#ifndef PNG_NO_POINTER_INDEXING #ifndef PNG_NO_POINTER_INDEXING
for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++) for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
{ {
@ -897,7 +900,7 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
#endif #endif
#if defined(PNG_WRITE_sBIT_SUPPORTED) #if defined(PNG_WRITE_sBIT_SUPPORTED)
/* write the sBIT chunk */ /* Write the sBIT chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
{ {
@ -908,7 +911,7 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
png_size_t size; png_size_t size;
png_debug(1, "in png_write_sBIT"); png_debug(1, "in png_write_sBIT");
/* make sure we don't depend upon the order of PNG_COLOR_8 */ /* Make sure we don't depend upon the order of PNG_COLOR_8 */
if (color_type & PNG_COLOR_MASK_COLOR) if (color_type & PNG_COLOR_MASK_COLOR)
{ {
png_byte maxbits; png_byte maxbits;
@ -953,7 +956,7 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
#endif #endif
#if defined(PNG_WRITE_cHRM_SUPPORTED) #if defined(PNG_WRITE_cHRM_SUPPORTED)
/* write the cHRM chunk */ /* Write the cHRM chunk */
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_write_cHRM(png_structp png_ptr, double white_x, double white_y, png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
@ -984,7 +987,7 @@ png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y)) int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y))
#endif #endif
{ {
/* each value is saved in 1/100,000ths */ /* Each value is saved in 1/100,000ths */
png_save_uint_32(buf, int_white_x); png_save_uint_32(buf, int_white_x);
png_save_uint_32(buf + 4, int_white_y); png_save_uint_32(buf + 4, int_white_y);
@ -1015,7 +1018,7 @@ png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
png_byte buf[32]; png_byte buf[32];
png_debug(1, "in png_write_cHRM"); png_debug(1, "in png_write_cHRM");
/* each value is saved in 1/100,000ths */ /* Each value is saved in 1/100,000ths */
#if !defined(PNG_NO_CHECK_cHRM) #if !defined(PNG_NO_CHECK_cHRM)
if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y, if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,
green_x, green_y, blue_x, blue_y)) green_x, green_y, blue_x, blue_y))
@ -1040,7 +1043,7 @@ png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
#endif #endif
#if defined(PNG_WRITE_tRNS_SUPPORTED) #if defined(PNG_WRITE_tRNS_SUPPORTED)
/* write the tRNS chunk */ /* Write the tRNS chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
int num_trans, int color_type) int num_trans, int color_type)
@ -1058,13 +1061,13 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
png_warning(png_ptr, "Invalid number of transparent colors specified"); png_warning(png_ptr, "Invalid number of transparent colors specified");
return; return;
} }
/* write the chunk out as it is */ /* Write the chunk out as it is */
png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans,
(png_size_t)num_trans); (png_size_t)num_trans);
} }
else if (color_type == PNG_COLOR_TYPE_GRAY) else if (color_type == PNG_COLOR_TYPE_GRAY)
{ {
/* one 16 bit value */ /* One 16 bit value */
if (tran->gray >= (1 << png_ptr->bit_depth)) if (tran->gray >= (1 << png_ptr->bit_depth))
{ {
png_warning(png_ptr, png_warning(png_ptr,
@ -1076,7 +1079,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
} }
else if (color_type == PNG_COLOR_TYPE_RGB) else if (color_type == PNG_COLOR_TYPE_RGB)
{ {
/* three 16 bit values */ /* Three 16 bit values */
png_save_uint_16(buf, tran->red); png_save_uint_16(buf, tran->red);
png_save_uint_16(buf + 2, tran->green); png_save_uint_16(buf + 2, tran->green);
png_save_uint_16(buf + 4, tran->blue); png_save_uint_16(buf + 4, tran->blue);
@ -1096,7 +1099,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
#endif #endif
#if defined(PNG_WRITE_bKGD_SUPPORTED) #if defined(PNG_WRITE_bKGD_SUPPORTED)
/* write the background chunk */ /* Write the background chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
{ {
@ -1149,7 +1152,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
#endif #endif
#if defined(PNG_WRITE_hIST_SUPPORTED) #if defined(PNG_WRITE_hIST_SUPPORTED)
/* write the histogram */ /* Write the histogram */
void /* PRIVATE */ void /* PRIVATE */
png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist) png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
{ {
@ -1311,7 +1314,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
#endif #endif
#if defined(PNG_WRITE_tEXt_SUPPORTED) #if defined(PNG_WRITE_tEXt_SUPPORTED)
/* write a tEXt chunk */ /* Write a tEXt chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text, png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len) png_size_t text_len)
@ -1331,7 +1334,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
else else
text_len = png_strlen(text); text_len = png_strlen(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_bytep)png_tEXt, png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,
(png_uint_32)(key_len + text_len + 1)); (png_uint_32)(key_len + text_len + 1));
/* /*
@ -1351,7 +1354,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
#endif #endif
#if defined(PNG_WRITE_zTXt_SUPPORTED) #if defined(PNG_WRITE_zTXt_SUPPORTED)
/* write a compressed text chunk */ /* Write a compressed text chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text, png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len, int compression) png_size_t text_len, int compression)
@ -1387,31 +1390,31 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
text_len = png_strlen(text); text_len = png_strlen(text);
/* compute the compressed data; do it now for the length */ /* Compute the compressed data; do it now for the length */
text_len = png_text_compress(png_ptr, text, text_len, compression, text_len = png_text_compress(png_ptr, text, text_len, compression,
&comp); &comp);
/* write start of chunk */ /* Write start of chunk */
png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,
(png_uint_32)(key_len+text_len + 2)); (png_uint_32)(key_len+text_len + 2));
/* write key */ /* Write key */
png_write_chunk_data(png_ptr, (png_bytep)new_key, png_write_chunk_data(png_ptr, (png_bytep)new_key,
(png_size_t)(key_len + 1)); (png_size_t)(key_len + 1));
png_free(png_ptr, new_key); png_free(png_ptr, new_key);
buf[0] = (png_byte)compression; buf[0] = (png_byte)compression;
/* write compression */ /* Write compression */
png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);
/* write the compressed data */ /* Write the compressed data */
png_write_compressed_data_out(png_ptr, &comp); png_write_compressed_data_out(png_ptr, &comp);
/* close the chunk */ /* Close the chunk */
png_write_chunk_end(png_ptr); png_write_chunk_end(png_ptr);
} }
#endif #endif
#if defined(PNG_WRITE_iTXt_SUPPORTED) #if defined(PNG_WRITE_iTXt_SUPPORTED)
/* write an iTXt chunk */ /* Write an iTXt chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_iTXt(png_structp png_ptr, int compression, png_charp key, png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
png_charp lang, png_charp lang_key, png_charp text) png_charp lang, png_charp lang_key, png_charp text)
@ -1452,12 +1455,12 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
else else
text_len = png_strlen(text); text_len = png_strlen(text);
/* compute the compressed data; do it now for the length */ /* Compute the compressed data; do it now for the length */
text_len = png_text_compress(png_ptr, text, text_len, compression-2, text_len = png_text_compress(png_ptr, text, text_len, compression-2,
&comp); &comp);
/* make sure we include the compression flag, the compression byte, /* Make sure we include the compression flag, the compression byte,
* and the NULs after the key, lang, and lang_key parts */ * and the NULs after the key, lang, and lang_key parts */
png_write_chunk_start(png_ptr, (png_bytep)png_iTXt, png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,
@ -1468,8 +1471,7 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
+ lang_key_len + lang_key_len
+ text_len)); + text_len));
/* /* We leave it to the application to meet PNG-1.0 requirements on the
* We leave it to the application to meet PNG-1.0 requirements on the
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
@ -1477,13 +1479,13 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
png_write_chunk_data(png_ptr, (png_bytep)new_key, png_write_chunk_data(png_ptr, (png_bytep)new_key,
(png_size_t)(key_len + 1)); (png_size_t)(key_len + 1));
/* set the compression flag */ /* Set the compression flag */
if (compression == PNG_ITXT_COMPRESSION_NONE || \ if (compression == PNG_ITXT_COMPRESSION_NONE || \
compression == PNG_TEXT_COMPRESSION_NONE) compression == PNG_TEXT_COMPRESSION_NONE)
cbuf[0] = 0; cbuf[0] = 0;
else /* compression == PNG_ITXT_COMPRESSION_zTXt */ else /* compression == PNG_ITXT_COMPRESSION_zTXt */
cbuf[0] = 1; cbuf[0] = 1;
/* set the compression method */ /* Set the compression method */
cbuf[1] = 0; cbuf[1] = 0;
png_write_chunk_data(png_ptr, cbuf, (png_size_t)2); png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);
@ -1501,7 +1503,7 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
#endif #endif
#if defined(PNG_WRITE_oFFs_SUPPORTED) #if defined(PNG_WRITE_oFFs_SUPPORTED)
/* write the oFFs chunk */ /* Write the oFFs chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
int unit_type) int unit_type)
@ -1523,7 +1525,7 @@ png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
} }
#endif #endif
#if defined(PNG_WRITE_pCAL_SUPPORTED) #if defined(PNG_WRITE_pCAL_SUPPORTED)
/* write the pCAL chunk (described in the PNG extensions document) */ /* Write the pCAL chunk (described in the PNG extensions document) */
void /* PRIVATE */ void /* PRIVATE */
png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
png_int_32 X1, int type, int nparams, png_charp units, png_charpp params) png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)
@ -1585,7 +1587,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
#endif #endif
#if defined(PNG_WRITE_sCAL_SUPPORTED) #if defined(PNG_WRITE_sCAL_SUPPORTED)
/* write the sCAL chunk */ /* Write the sCAL chunk */
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) #if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
void /* PRIVATE */ void /* PRIVATE */
png_write_sCAL(png_structp png_ptr, int unit, double width, double height) png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
@ -1648,8 +1650,8 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
} }
buf[0] = (png_byte)unit; buf[0] = (png_byte)unit;
png_memcpy(buf + 1, width, wlen + 1); /* append the '\0' here */ png_memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */
png_memcpy(buf + wlen + 2, height, hlen); /* do NOT append the '\0' here */ png_memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */
png_debug1(3, "sCAL total length = %u", (unsigned int)total_len); png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len); png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);
@ -1659,7 +1661,7 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
#endif #endif
#if defined(PNG_WRITE_pHYs_SUPPORTED) #if defined(PNG_WRITE_pHYs_SUPPORTED)
/* write the pHYs chunk */ /* Write the pHYs chunk */
void /* PRIVATE */ void /* PRIVATE */
png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
png_uint_32 y_pixels_per_unit, png_uint_32 y_pixels_per_unit,
@ -1714,24 +1716,24 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time)
} }
#endif #endif
/* initializes the row writing capability of libpng */ /* Initializes the row writing capability of libpng */
void /* PRIVATE */ void /* PRIVATE */
png_write_start_row(png_structp png_ptr) png_write_start_row(png_structp png_ptr)
{ {
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; int png_pass_ystart[7] = {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 png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif #endif
#endif #endif
@ -1742,13 +1744,13 @@ png_write_start_row(png_structp png_ptr)
buf_size = (png_size_t)(PNG_ROWBYTES( buf_size = (png_size_t)(PNG_ROWBYTES(
png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1); png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
/* set up row buffer */ /* Set up row buffer */
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)buf_size); (png_uint_32)buf_size);
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
#ifndef PNG_NO_WRITE_FILTER #ifndef PNG_NO_WRITE_FILTER
/* set up filtering buffer, if using this filter */ /* Set up filtering buffer, if using this filter */
if (png_ptr->do_filter & PNG_FILTER_SUB) if (png_ptr->do_filter & PNG_FILTER_SUB)
{ {
png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
@ -1759,7 +1761,7 @@ png_write_start_row(png_structp png_ptr)
/* We only need to keep the previous row if we are using one of these. */ /* We only need to keep the previous row if we are using one of these. */
if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
{ {
/* set up previous row buffer */ /* Set up previous row buffer */
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->prev_row = (png_bytep)png_malloc(png_ptr,
(png_uint_32)buf_size); (png_uint_32)buf_size);
png_memset(png_ptr->prev_row, 0, buf_size); png_memset(png_ptr->prev_row, 0, buf_size);
@ -1788,7 +1790,7 @@ png_write_start_row(png_structp png_ptr)
#endif /* PNG_NO_WRITE_FILTER */ #endif /* PNG_NO_WRITE_FILTER */
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
/* if interlaced, we need to set up width and height of pass */ /* If interlaced, we need to set up width and height of pass */
if (png_ptr->interlaced) if (png_ptr->interlaced)
{ {
if (!(png_ptr->transformations & PNG_INTERLACE)) if (!(png_ptr->transformations & PNG_INTERLACE))
@ -1820,18 +1822,18 @@ png_write_finish_row(png_structp png_ptr)
{ {
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; int png_pass_ystart[7] = {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 png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif #endif
#endif #endif
@ -1839,15 +1841,15 @@ png_write_finish_row(png_structp png_ptr)
int ret; int ret;
png_debug(1, "in png_write_finish_row"); png_debug(1, "in png_write_finish_row");
/* next row */ /* Next row */
png_ptr->row_number++; png_ptr->row_number++;
/* see if we are done */ /* See if we are done */
if (png_ptr->row_number < png_ptr->num_rows) if (png_ptr->row_number < png_ptr->num_rows)
return; return;
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
/* if interlaced, go to next pass */ /* If interlaced, go to next pass */
if (png_ptr->interlaced) if (png_ptr->interlaced)
{ {
png_ptr->row_number = 0; png_ptr->row_number = 0;
@ -1857,7 +1859,7 @@ png_write_finish_row(png_structp png_ptr)
} }
else else
{ {
/* loop until we find a non-zero width or height pass */ /* Loop until we find a non-zero width or height pass */
do do
{ {
png_ptr->pass++; png_ptr->pass++;
@ -1877,7 +1879,7 @@ png_write_finish_row(png_structp png_ptr)
} }
/* reset the row above the image for the next pass */ /* Reset the row above the image for the next pass */
if (png_ptr->pass < 7) if (png_ptr->pass < 7)
{ {
if (png_ptr->prev_row != NULL) if (png_ptr->prev_row != NULL)
@ -1889,16 +1891,16 @@ png_write_finish_row(png_structp png_ptr)
} }
#endif #endif
/* if we get here, we've just written the last row, so we need /* If we get here, we've just written the last row, so we need
to flush the compressor */ to flush the compressor */
do do
{ {
/* tell the compressor we are done */ /* Tell the compressor we are done */
ret = deflate(&png_ptr->zstream, Z_FINISH); ret = deflate(&png_ptr->zstream, Z_FINISH);
/* check for an error */ /* Check for an error */
if (ret == Z_OK) if (ret == Z_OK)
{ {
/* check to see if we need more room */ /* Check to see if we need more room */
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
@ -1915,7 +1917,7 @@ png_write_finish_row(png_structp png_ptr)
} }
} while (ret != Z_STREAM_END); } while (ret != Z_STREAM_END);
/* write any extra space */ /* Write any extra space */
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
{ {
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -
@ -1938,24 +1940,24 @@ void /* PRIVATE */
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)
{ {
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
#endif #endif
png_debug(1, "in png_do_write_interlace"); png_debug(1, "in png_do_write_interlace");
/* we don't have to do anything on the last pass (6) */ /* We don't have to do anything on the last pass (6) */
#if defined(PNG_USELESS_TESTS_SUPPORTED) #if defined(PNG_USELESS_TESTS_SUPPORTED)
if (row != NULL && row_info != NULL && pass < 6) if (row != NULL && row_info != NULL && pass < 6)
#else #else
if (pass < 6) if (pass < 6)
#endif #endif
{ {
/* each pixel depth is handled separately */ /* Each pixel depth is handled separately */
switch (row_info->pixel_depth) switch (row_info->pixel_depth)
{ {
case 1: case 1:
@ -2066,27 +2068,27 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
png_uint_32 row_width = row_info->width; png_uint_32 row_width = row_info->width;
png_size_t pixel_bytes; png_size_t pixel_bytes;
/* start at the beginning */ /* Start at the beginning */
dp = row; dp = row;
/* find out how many bytes each pixel takes up */ /* Find out how many bytes each pixel takes up */
pixel_bytes = (row_info->pixel_depth >> 3); pixel_bytes = (row_info->pixel_depth >> 3);
/* loop through the row, only looking at the pixels that /* Loop through the row, only looking at the pixels that
matter */ matter */
for (i = png_pass_start[pass]; i < row_width; for (i = png_pass_start[pass]; i < row_width;
i += png_pass_inc[pass]) i += png_pass_inc[pass])
{ {
/* find out where the original pixel is */ /* Find out where the original pixel is */
sp = row + (png_size_t)i * pixel_bytes; sp = row + (png_size_t)i * pixel_bytes;
/* move the pixel */ /* Move the pixel */
if (dp != sp) if (dp != sp)
png_memcpy(dp, sp, pixel_bytes); png_memcpy(dp, sp, pixel_bytes);
/* next pixel */ /* Next pixel */
dp += pixel_bytes; dp += pixel_bytes;
} }
break; break;
} }
} }
/* set new row width */ /* Set new row width */
row_info->width = (row_info->width + row_info->width = (row_info->width +
png_pass_inc[pass] - 1 - png_pass_inc[pass] - 1 -
png_pass_start[pass]) / png_pass_start[pass]) /
@ -2119,7 +2121,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
#endif #endif
png_debug(1, "in png_write_find_filter"); png_debug(1, "in png_write_find_filter");
/* find out how many bytes offset each pixel is */ /* Find out how many bytes offset each pixel is */
bpp = (row_info->pixel_depth + 7) >> 3; bpp = (row_info->pixel_depth + 7) >> 3;
prev_row = png_ptr->prev_row; prev_row = png_ptr->prev_row;
@ -2206,9 +2208,9 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
mins = sum; mins = sum;
} }
/* sub filter */ /* Sub filter */
if (filter_to_do == PNG_FILTER_SUB) if (filter_to_do == PNG_FILTER_SUB)
/* it's the only filter so no testing is needed */ /* It's the only filter so no testing is needed */
{ {
png_bytep rp, lp, dp; png_bytep rp, lp, dp;
png_uint_32 i; png_uint_32 i;
@ -2323,7 +2325,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
} }
} }
/* up filter */ /* Up filter */
if (filter_to_do == PNG_FILTER_UP) if (filter_to_do == PNG_FILTER_UP)
{ {
png_bytep rp, dp, pp; png_bytep rp, dp, pp;
@ -2426,7 +2428,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
} }
} }
/* avg filter */ /* Avg filter */
if (filter_to_do == PNG_FILTER_AVG) if (filter_to_do == PNG_FILTER_AVG)
{ {
png_bytep rp, dp, pp, lp; png_bytep rp, dp, pp, lp;
@ -2729,18 +2731,18 @@ png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
{ {
png_debug(1, "in png_write_filtered_row"); png_debug(1, "in png_write_filtered_row");
png_debug1(2, "filter = %d", filtered_row[0]); png_debug1(2, "filter = %d", filtered_row[0]);
/* set up the zlib input buffer */ /* Set up the zlib input buffer */
png_ptr->zstream.next_in = filtered_row; png_ptr->zstream.next_in = filtered_row;
png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1; png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;
/* repeat until we have compressed all the data */ /* Repeat until we have compressed all the data */
do do
{ {
int ret; /* return of zlib */ int ret; /* Return of zlib */
/* compress the data */ /* Compress the data */
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
/* check for compression errors */ /* Check for compression errors */
if (ret != Z_OK) if (ret != Z_OK)
{ {
if (png_ptr->zstream.msg != NULL) if (png_ptr->zstream.msg != NULL)
@ -2749,18 +2751,18 @@ png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
png_error(png_ptr, "zlib error"); png_error(png_ptr, "zlib error");
} }
/* see if it is time to write another IDAT */ /* See if it is time to write another IDAT */
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
/* write the IDAT and reset the zlib output buffer */ /* Write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
png_ptr->zstream.next_out = png_ptr->zbuf; png_ptr->zstream.next_out = png_ptr->zbuf;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
} }
/* repeat until all data has been compressed */ /* Repeat until all data has been compressed */
} while (png_ptr->zstream.avail_in); } while (png_ptr->zstream.avail_in);
/* swap the current and previous rows */ /* Swap the current and previous rows */
if (png_ptr->prev_row != NULL) if (png_ptr->prev_row != NULL)
{ {
png_bytep tptr; png_bytep tptr;
@ -2770,7 +2772,7 @@ png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
png_ptr->row_buf = tptr; png_ptr->row_buf = tptr;
} }
/* finish row - updates counters and flushes zlib if last row */ /* Finish row - updates counters and flushes zlib if last row */
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
#if defined(PNG_WRITE_FLUSH_SUPPORTED) #if defined(PNG_WRITE_FLUSH_SUPPORTED)

2
scripts/CMakeLists.txt
View File

@ -169,7 +169,7 @@ configure_file(${PNG_SOURCE_DIR}/scripts/libpng-config.in
# SET UP LINKS # SET UP LINKS
set_target_properties(${PNG_LIB_NAME} PROPERTIES set_target_properties(${PNG_LIB_NAME} PROPERTIES
# VERSION 0.${PNGLIB_RELEASE}.1.2.37rc01 # VERSION 0.${PNGLIB_RELEASE}.1.2.37beta03
VERSION 0.${PNGLIB_RELEASE}.0 VERSION 0.${PNGLIB_RELEASE}.0
SOVERSION 0 SOVERSION 0
CLEAN_DIRECT_OUTPUT 1) CLEAN_DIRECT_OUTPUT 1)

2
scripts/libpng-config-head.in
View File

@ -8,7 +8,7 @@
# Modeled after libxml-config. # Modeled after libxml-config.
version=1.2.37rc01 version=1.2.37beta03
prefix="" prefix=""
libdir="" libdir=""
libs="" libs=""

2
scripts/libpng.pc.in
View File

@ -5,6 +5,6 @@ includedir=@includedir@/libpng12
Name: libpng Name: libpng
Description: Loads and saves PNG files Description: Loads and saves PNG files
Version: 1.2.37rc01 Version: 1.2.37beta03
Libs: -L${libdir} -lpng12 Libs: -L${libdir} -lpng12
Cflags: -I${includedir} Cflags: -I${includedir}

2
scripts/makefile.32sunu
View File

@ -8,7 +8,7 @@
# Library name: # Library name:
LIBNAME=libpng12 LIBNAME=libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.64sunu
View File

@ -8,7 +8,7 @@
# Library name: # Library name:
LIBNAME=libpng12 LIBNAME=libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.aix
View File

@ -20,7 +20,7 @@ LN_SF = ln -f -s
LIBNAME=libpng12 LIBNAME=libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
prefix=/usr/local prefix=/usr/local

2
scripts/makefile.beos
View File

@ -8,7 +8,7 @@
# Library name: # Library name:
LIBNAME=libpng12 LIBNAME=libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.cygwin
View File

@ -74,7 +74,7 @@ CFLAGS= $(strip $(MINGW_CCFLAGS) $(addprefix -I,$(ZLIBINC)) \
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
CYGDLL = 12 CYGDLL = 12
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
SHAREDLIB=cygpng$(CYGDLL).dll SHAREDLIB=cygpng$(CYGDLL).dll

2
scripts/makefile.darwin
View File

@ -19,7 +19,7 @@ ZLIBINC=../zlib
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 12 PNGMAJ = 12
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.dec
View File

@ -5,7 +5,7 @@
# Library name: # Library name:
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
LIBNAME = libpng12 LIBNAME = libpng12

2
scripts/makefile.elf
View File

@ -13,7 +13,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.gcmmx
View File

@ -14,7 +14,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.hp64
View File

@ -18,7 +18,7 @@ ZLIBINC=/opt/zlib/include
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.hpgcc
View File

@ -8,7 +8,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.hpux
View File

@ -18,7 +18,7 @@ ZLIBINC=/opt/zlib/include
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.linux
View File

@ -7,7 +7,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.mingw
View File

@ -74,7 +74,7 @@ CFLAGS= $(strip $(MINGW_CCFLAGS) $(addprefix -I,$(ZLIBINC)) \
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
MINGDLL = 12 MINGDLL = 12
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
SHAREDLIB=libpng$(MINGDLL).dll SHAREDLIB=libpng$(MINGDLL).dll

2
scripts/makefile.ne12bsd
View File

@ -14,7 +14,7 @@ INCSDIR=${LOCALBASE}/include/libpng12
LIB= png12 LIB= png12
SHLIB_MAJOR= 0 SHLIB_MAJOR= 0
SHLIB_MINOR= 1.2.37rc01 SHLIB_MINOR= 1.2.37beta03
SRCS= png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \ SRCS= png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \ pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
pngwtran.c pngmem.c pngerror.c pngpread.c pngwtran.c pngmem.c pngerror.c pngpread.c

2
scripts/makefile.netbsd
View File

@ -14,7 +14,7 @@ INCSDIR=${LOCALBASE}/include/libpng
LIB= png LIB= png
SHLIB_MAJOR= 3 SHLIB_MAJOR= 3
SHLIB_MINOR= 1.2.37rc01 SHLIB_MINOR= 1.2.37beta03
SRCS= png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \ SRCS= png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \ pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
pngwtran.c pngmem.c pngerror.c pngpread.c pngwtran.c pngmem.c pngerror.c pngpread.c

2
scripts/makefile.nommx
View File

@ -7,7 +7,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.openbsd
View File

@ -8,7 +8,7 @@ LIBDIR= ${PREFIX}/lib
MANDIR= ${PREFIX}/man/cat MANDIR= ${PREFIX}/man/cat
SHLIB_MAJOR= 0 SHLIB_MAJOR= 0
SHLIB_MINOR= 1.2.37rc01 SHLIB_MINOR= 1.2.37beta03
LIB= png LIB= png
SRCS= png.c pngerror.c pngget.c pngmem.c pngpread.c \ SRCS= png.c pngerror.c pngget.c pngmem.c pngpread.c \

2
scripts/makefile.sco
View File

@ -9,7 +9,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.sggcc
View File

@ -6,7 +6,7 @@
# Library name: # Library name:
LIBNAME=libpng12 LIBNAME=libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.sgi
View File

@ -6,7 +6,7 @@
# Library name: # Library name:
LIBNAME=libpng12 LIBNAME=libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.so9
View File

@ -8,7 +8,7 @@
# Library name: # Library name:
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
LIBNAME = libpng12 LIBNAME = libpng12

2
scripts/makefile.solaris
View File

@ -8,7 +8,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/makefile.solaris-x86
View File

@ -8,7 +8,7 @@
# Library name: # Library name:
LIBNAME = libpng12 LIBNAME = libpng12
PNGMAJ = 0 PNGMAJ = 0
PNGMIN = 1.2.37rc01 PNGMIN = 1.2.37beta03
PNGVER = $(PNGMAJ).$(PNGMIN) PNGVER = $(PNGMAJ).$(PNGMIN)
# Shared library names: # Shared library names:

2
scripts/pngos2.def
View File

@ -2,7 +2,7 @@
; PNG.LIB module definition file for OS/2 ; PNG.LIB module definition file for OS/2
;---------------------------------------- ;----------------------------------------
; Version 1.2.37rc01 ; Version 1.2.37beta03
LIBRARY PNG LIBRARY PNG
DESCRIPTION "PNG image compression library for OS/2" DESCRIPTION "PNG image compression library for OS/2"

2
scripts/pngw32.def
View File

@ -5,7 +5,7 @@
LIBRARY LIBRARY
EXPORTS EXPORTS
;Version 1.2.37rc01 ;Version 1.2.37beta03
png_build_grayscale_palette @1 png_build_grayscale_palette @1
png_check_sig @2 png_check_sig @2
png_chunk_error @3 png_chunk_error @3