Updated libpng to 1.4.0

git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@1482 10f7b99b-c216-0410-bff0-8a66a9350fd8

22 files changed, 26526 insertions, 28971 deletions

diff --git a/src/libpng/LICENSE b/src/libpng/LICENSE
index 3955d0656..7462ec351 100644
--- a/src/libpng/LICENSE
+++ b/src/libpng/LICENSE
@@ -1,111 +1,111 @@
-

-This copy of the libpng notices is provided for your convenience.  In case of

-any discrepancy between this copy and the notices in the file png.h that is

-included in the libpng distribution, the latter shall prevail.

-

-COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

-

-If you modify libpng you may insert additional notices immediately following

-this sentence.

-

-This code is released under the libpng license.

-

-libpng versions 1.2.6, August 15, 2004, through 1.2.41, December 3, 2009, are

-Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are

-distributed according to the same disclaimer and license as libpng-1.2.5

-with the following individual added to the list of Contributing Authors

-

-   Cosmin Truta

-

-libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are

-Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are

-distributed according to the same disclaimer and license as libpng-1.0.6

-with the following individuals added to the list of Contributing Authors

-

-   Simon-Pierre Cadieux

-   Eric S. Raymond

-   Gilles Vollant

-

-and with the following additions to the disclaimer:

-

-   There is no warranty against interference with your enjoyment of the

-   library or against infringement.  There is no warranty that our

-   efforts or the library will fulfill any of your particular purposes

-   or needs.  This library is provided with all faults, and the entire

-   risk of satisfactory quality, performance, accuracy, and effort is with

-   the user.

-

-libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are

-Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are

-distributed according to the same disclaimer and license as libpng-0.96,

-with the following individuals added to the list of Contributing Authors:

-

-   Tom Lane

-   Glenn Randers-Pehrson

-   Willem van Schaik

-

-libpng versions 0.89, June 1996, through 0.96, May 1997, are

-Copyright (c) 1996, 1997 Andreas Dilger

-Distributed according to the same disclaimer and license as libpng-0.88,

-with the following individuals added to the list of Contributing Authors:

-

-   John Bowler

-   Kevin Bracey

-   Sam Bushell

-   Magnus Holmgren

-   Greg Roelofs

-   Tom Tanner

-

-libpng versions 0.5, May 1995, through 0.88, January 1996, are

-Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.

-

-For the purposes of this copyright and license, "Contributing Authors"

-is defined as the following set of individuals:

-

-   Andreas Dilger

-   Dave Martindale

-   Guy Eric Schalnat

-   Paul Schmidt

-   Tim Wegner

-

-The PNG Reference Library is supplied "AS IS".  The Contributing Authors

-and Group 42, Inc. disclaim all warranties, expressed or implied,

-including, without limitation, the warranties of merchantability and of

-fitness for any purpose.  The Contributing Authors and Group 42, Inc.

-assume no liability for direct, indirect, incidental, special, exemplary,

-or consequential damages, which may result from the use of the PNG

-Reference Library, even if advised of the possibility of such damage.

-

-Permission is hereby granted to use, copy, modify, and distribute this

-source code, or portions hereof, for any purpose, without fee, subject

-to the following restrictions:

-

-1. The origin of this source code must not be misrepresented.

-

-2. Altered versions must be plainly marked as such and must not

-   be misrepresented as being the original source.

-

-3. This Copyright notice may not be removed or altered from any

-   source or altered source distribution.

-

-The Contributing Authors and Group 42, Inc. specifically permit, without

-fee, and encourage the use of this source code as a component to

-supporting the PNG file format in commercial products.  If you use this

-source code in a product, acknowledgment is not required but would be

-appreciated.

-

-

-A "png_get_copyright" function is available, for convenient use in "about"

-boxes and the like:

-

-   printf("%s",png_get_copyright(NULL));

-

-Also, the PNG logo (in PNG format, of course) is supplied in the

-files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).

-

-Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is a

-certification mark of the Open Source Initiative.

-

-Glenn Randers-Pehrson

-glennrp at users.sourceforge.net

-December 3, 2009

+
+This copy of the libpng notices is provided for your convenience.  In case of
+any discrepancy between this copy and the notices in the file png.h that is
+included in the libpng distribution, the latter shall prevail.
+
+COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+
+If you modify libpng you may insert additional notices immediately following
+this sentence.
+
+This code is released under the libpng license.
+
+libpng versions 1.2.6, August 15, 2004, through 1.4.0, January 3, 2010, are
+Copyright (c) 2004, 2006-2007 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.2.5
+with the following individual added to the list of Contributing Authors
+
+   Cosmin Truta
+
+libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are
+Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.0.6
+with the following individuals added to the list of Contributing Authors
+
+   Simon-Pierre Cadieux
+   Eric S. Raymond
+   Gilles Vollant
+
+and with the following additions to the disclaimer:
+
+   There is no warranty against interference with your enjoyment of the
+   library or against infringement.  There is no warranty that our
+   efforts or the library will fulfill any of your particular purposes
+   or needs.  This library is provided with all faults, and the entire
+   risk of satisfactory quality, performance, accuracy, and effort is with
+   the user.
+
+libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-0.96,
+with the following individuals added to the list of Contributing Authors:
+
+   Tom Lane
+   Glenn Randers-Pehrson
+   Willem van Schaik
+
+libpng versions 0.89, June 1996, through 0.96, May 1997, are
+Copyright (c) 1996, 1997 Andreas Dilger
+Distributed according to the same disclaimer and license as libpng-0.88,
+with the following individuals added to the list of Contributing Authors:
+
+   John Bowler
+   Kevin Bracey
+   Sam Bushell
+   Magnus Holmgren
+   Greg Roelofs
+   Tom Tanner
+
+libpng versions 0.5, May 1995, through 0.88, January 1996, are
+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+
+For the purposes of this copyright and license, "Contributing Authors"
+is defined as the following set of individuals:
+
+   Andreas Dilger
+   Dave Martindale
+   Guy Eric Schalnat
+   Paul Schmidt
+   Tim Wegner
+
+The PNG Reference Library is supplied "AS IS".  The Contributing Authors
+and Group 42, Inc. disclaim all warranties, expressed or implied,
+including, without limitation, the warranties of merchantability and of
+fitness for any purpose.  The Contributing Authors and Group 42, Inc.
+assume no liability for direct, indirect, incidental, special, exemplary,
+or consequential damages, which may result from the use of the PNG
+Reference Library, even if advised of the possibility of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+source code, or portions hereof, for any purpose, without fee, subject
+to the following restrictions:
+
+1. The origin of this source code must not be misrepresented.
+
+2. Altered versions must be plainly marked as such and must not
+   be misrepresented as being the original source.
+
+3. This Copyright notice may not be removed or altered from any
+   source or altered source distribution.
+
+The Contributing Authors and Group 42, Inc. specifically permit, without
+fee, and encourage the use of this source code as a component to
+supporting the PNG file format in commercial products.  If you use this
+source code in a product, acknowledgment is not required but would be
+appreciated.
+
+
+A "png_get_copyright" function is available, for convenient use in "about"
+boxes and the like:
+
+   printf("%s",png_get_copyright(NULL));
+
+Also, the PNG logo (in PNG format, of course) is supplied in the
+files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+
+Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is a
+certification mark of the Open Source Initiative.
+
+Glenn Randers-Pehrson
+glennrp at users.sourceforge.net
+January 3, 2010
diff --git a/src/libpng/README b/src/libpng/README
index 305bcbdb0..68d7a8e45 100644
--- a/src/libpng/README
+++ b/src/libpng/README
@@ -1,275 +1,257 @@
-README for libpng version 1.2.41 - December 3, 2009 (shared library 12.0)

-See the note about version numbers near the top of png.h

-

-See INSTALL for instructions on how to install libpng.

-

-Libpng comes in several distribution formats.  Get libpng-*.tar.gz,

-libpng-*.tar.xz, or libpng-*.tar.bz2 if you want UNIX-style line

-endings in the text files, or lpng*.7z or lpng*.zip if you want DOS-style

-line endings.  You can get UNIX-style line endings from the *.zip file

-by using "unzip -a" but there seems to be no simple way to recover

-UNIX-style line endings from the *.7z file.  The *.tar.xz file is

-recommended for *NIX users instead.

-

-Version 0.89 was the first official release of libpng.  Don't let the

-fact that it's the first release fool you.  The libpng library has been in

-extensive use and testing since mid-1995.  By late 1997 it had

-finally gotten to the stage where there hadn't been significant

-changes to the API in some time, and people have a bad feeling about

-libraries with versions < 1.0.  Version 1.0.0 was released in

-March 1998.

-

-****

-Note that some of the changes to the png_info structure render this

-version of the library binary incompatible with libpng-0.89 or

-earlier versions if you are using a shared library.  The type of the

-"filler" parameter for png_set_filler() has changed from png_byte to

-png_uint_32, which will affect shared-library applications that use

-this function.

-

-To avoid problems with changes to the internals of png_info_struct,

-new APIs have been made available in 0.95 to avoid direct application

-access to info_ptr.  These functions are the png_set_<chunk> and

-png_get_<chunk> functions.  These functions should be used when

-accessing/storing the info_struct data, rather than manipulating it

-directly, to avoid such problems in the future.

-

-It is important to note that the APIs do not make current programs

-that access the info struct directly incompatible with the new

-library.  However, it is strongly suggested that new programs use

-the new APIs (as shown in example.c and pngtest.c), and older programs

-be converted to the new format, to facilitate upgrades in the future.

-****

-

-Additions since 0.90 include the ability to compile libpng as a

-Windows DLL, and new APIs for accessing data in the info struct.

-Experimental functions include the ability to set weighting and cost

-factors for row filter selection, direct reads of integers from buffers

-on big-endian processors that support misaligned data access, faster

-methods of doing alpha composition, and more accurate 16->8 bit color

-conversion.

-

-The additions since 0.89 include the ability to read from a PNG stream

-which has had some (or all) of the signature bytes read by the calling

-application.  This also allows the reading of embedded PNG streams that

-do not have the PNG file signature.  As well, it is now possible to set

-the library action on the detection of chunk CRC errors.  It is possible

-to set different actions based on whether the CRC error occurred in a

-critical or an ancillary chunk.

-

-The changes made to the library, and bugs fixed are based on discussions

-on the png-mng-implement mailing list and not on material submitted

-privately to Guy, Andreas, or Glenn.  They will forward any good

-suggestions to the list.

-

-For a detailed description on using libpng, read libpng.txt.  For

-examples of libpng in a program, see example.c and pngtest.c.  For usage

-information and restrictions (what little they are) on libpng, see

-png.h.  For a description on using zlib (the compression library used by

-libpng) and zlib's restrictions, see zlib.h

-

-I have included a general makefile, as well as several machine and

-compiler specific ones, but you may have to modify one for your own needs.

-

-You should use zlib 1.0.4 or later to run this, but it MAY work with

-versions as old as zlib 0.95.  Even so, there are bugs in older zlib

-versions which can cause the output of invalid compression streams for

-some images.  You will definitely need zlib 1.0.4 or later if you are

-taking advantage of the MS-DOS "far" structure allocation for the small

-and medium memory models.  You should also note that zlib is a

-compression library that is useful for more things than just PNG files.

-You can use zlib as a drop-in replacement for fread() and fwrite() if

-you are so inclined.

-

-zlib should be available at the same place that libpng is, or at

-ftp://ftp.simplesystems.org/pub/png/src/

-

-You may also want a copy of the PNG specification.  It is available

-as an RFC, a W3C Recommendation, and an ISO/IEC Standard.  You can find

-these at http://www.libpng.org/pub/png/pngdocs.html

-

-This code is currently being archived at libpng.sf.net in the

-[DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT)

-at GO GRAPHSUP.  If you can't find it in any of those places,

-e-mail me, and I'll help you find it.

-

-If you have any code changes, requests, problems, etc., please e-mail

-them to me.  Also, I'd appreciate any make files or project files,

-and any modifications you needed to make to get libpng to compile,

-along with a #define variable to tell what compiler/system you are on.

-If you needed to add transformations to libpng, or wish libpng would

-provide the image in a different way, drop me a note (and code, if

-possible), so I can consider supporting the transformation.

-Finally, if you get any warning messages when compiling libpng

-(note: not zlib), and they are easy to fix, I'd appreciate the

-fix.  Please mention "libpng" somewhere in the subject line.  Thanks.

-

-This release was created and will be supported by myself (of course

-based in a large way on Guy's and Andreas' earlier work), and the PNG

-development group.

-

-Send comments/corrections/commendations to png-mng-implement at lists.sf.net

-(subscription required; visit 

-https://lists.sourceforge.net/lists/listinfo/png-mng-implement

-to subscribe) or to glennrp at users.sourceforge.net

-

-You can't reach Guy, the original libpng author, at the addresses

-given in previous versions of this document.  He and Andreas will

-read mail addressed to the png-mng-implement list, however.

-

-Please do not send general questions about PNG.  Send them to

-the (png-mng-misc at lists.sourceforge.net, subscription required, visit

-https://lists.sourceforge.net/lists/listinfo/png-mng-misc to

-subscribe). On the other hand, please do not send libpng questions to

-that address, send them to me or to the png-mng-implement list.  I'll

-get them in the end anyway.  If you have a question about something

-in the PNG specification that is related to using libpng, send it

-to me.  Send me any questions that start with "I was using libpng,

-and ...".  If in doubt, send questions to me.  I'll bounce them

-to others, if necessary.

-

-Please do not send suggestions on how to change PNG.  We have

-been discussing PNG for twelve years now, and it is official and

-finished.  If you have suggestions for libpng, however, I'll

-gladly listen.  Even if your suggestion is not used immediately,

-it may be used later.

-

-Files in this distribution:

-

-      ANNOUNCE      =>  Announcement of this version, with recent changes

-      CHANGES       =>  Description of changes between libpng versions

-      KNOWNBUG      =>  List of known bugs and deficiencies

-      LICENSE       =>  License to use and redistribute libpng

-      README        =>  This file

-      TODO          =>  Things not implemented in the current library

-      Y2KINFO       =>  Statement of Y2K compliance

-      example.c     =>  Example code for using libpng functions

-      libpng-*-*-diff.txt => Diff from previous release

-      libpng.3      =>  manual page for libpng (includes libpng.txt)

-      libpng.txt    =>  Description of libpng and its functions

-      libpngpf.3    =>  manual page for libpng's private functions

-      png.5         =>  manual page for the PNG format

-      png.c         =>  Basic interface functions common to library

-      png.h         =>  Library function and interface declarations

-      pngconf.h     =>  System specific library configuration

-      pngerror.c    =>  Error/warning message I/O functions

-      pngget.c      =>  Functions for retrieving info from struct

-      pngmem.c      =>  Memory handling functions

-      pngbar.png    =>  PNG logo, 88x31

-      pngnow.png    =>  PNG logo, 98x31

-      pngpread.c    =>  Progressive reading functions

-      pngread.c     =>  Read data/helper high-level functions

-      pngrio.c      =>  Lowest-level data read I/O functions

-      pngrtran.c    =>  Read data transformation functions

-      pngrutil.c    =>  Read data utility functions

-      pngset.c      =>  Functions for storing data into the info_struct

-      pngtest.c     =>  Library test program

-      pngtest.png   =>  Library test sample image

-      pngtrans.c    =>  Common data transformation functions

-      pngwio.c      =>  Lowest-level write I/O functions

-      pngwrite.c    =>  High-level write functions

-      pngwtran.c    =>  Write data transformations

-      pngwutil.c    =>  Write utility functions

-      contrib       =>  Contributions

-       gregbook         =>  source code for PNG reading and writing, from

-                            Greg Roelofs' "PNG: The Definitive Guide",

-                            O'Reilly, 1999

-       msvctest     =>  Builds and runs pngtest using a MSVC workspace

-       pngminim     =>  Simple pnm2pngm and png2pnmm programs

-       pngminus     =>  Simple pnm2png and png2pnm programs

-       pngsuite     =>  Test images

-       visupng      =>  Contains a MSVC workspace for VisualPng

-      projects      =>  Contains project files and workspaces for

-                        building a DLL

-       beos             =>  Contains a Beos workspace for building libpng

-       c5builder        =>  Contains a Borland workspace for building

-                            libpng and zlib

-       netware.txt      =>  Contains instructions for downloading a set

-                            of project files for building libpng and

-                            zlib on Netware.

-       visualc6         =>  Contains a Microsoft Visual C++ (MSVC)

-                            workspace for building libpng and zlib

-       wince.txt        =>  Contains instructions for downloading a

-                            Microsoft Visual C++ (Windows CD Toolkit)

-                            workspace for building libpng and zlib on

-                            WindowsCE

-       xcode            =>  Contains xcode project files

-      scripts       =>  Directory containing scripts for building libpng:

-       descrip.mms      =>  VMS makefile for MMS or MMK

-       makefile.std     =>  Generic UNIX makefile (cc, creates static

-                            libpng.a)

-       makefile.elf     =>  Linux/ELF gcc makefile symbol versioning,

-                            creates libpng12.so.0.1.2.41)

-       makefile.linux   =>  Linux/ELF makefile (gcc, creates

-                            libpng12.so.0.1.2.41)

-       makefile.gcmmx   =>  Linux/ELF makefile (gcc, creates

-                            libpng12.so.0.1.2.41, previously

-                            used assembler code tuned for Intel MMX

-                            platform)

-       makefile.gcc     =>  Generic makefile (gcc, creates static

-                            libpng.a)

-       makefile.knr     =>  Archaic UNIX Makefile that converts files

-                            with ansi2knr (Requires ansi2knr.c from

-                            ftp://ftp.cs.wisc.edu/ghost)

-       makefile.aix     =>  AIX makefile

-       makefile.cygwin  =>  Cygwin/gcc makefile

-       makefile.darwin  =>  Darwin makefile

-       makefile.dec     =>  DEC Alpha UNIX makefile

-       makefile.freebsd =>  FreeBSD makefile

-       makefile.hpgcc   =>  HPUX makefile using gcc

-       makefile.hpux    =>  HPUX (10.20 and 11.00) makefile

-       makefile.hp64    =>  HPUX (10.20 and 11.00) makefile, 64 bit

-       makefile.ibmc    =>  IBM C/C++ version 3.x for Win32 and OS/2

-                            (static)

-       makefile.intel   =>  Intel C/C++ version 4.0 and later

-       libpng.icc       =>  Project file, IBM VisualAge/C++ 4.0 or later

-       makefile.netbsd  =>  NetBSD/cc makefile, makes libpng.so.

-       makefile.ne12bsd  =>  NetBSD/cc makefile, makes libpng12.so

-       makefile.openbsd =>  OpenBSD makefile

-       makefile.sgi     =>  Silicon Graphics IRIX (cc, creates static lib)

-       makefile.sggcc   =>  Silicon Graphics

-                            (gcc, creates libpng12.so.0.1.2.41)

-       makefile.sunos   =>  Sun makefile

-       makefile.solaris =>  Solaris 2.X makefile

-                            (gcc, creates libpng12.so.0.1.2.41)

-       makefile.so9     =>  Solaris 9 makefile

-                            (gcc, creates libpng12.so.0.1.2.41)

-       makefile.32sunu  =>  Sun Ultra 32-bit makefile

-       makefile.64sunu  =>  Sun Ultra 64-bit makefile

-       makefile.sco     =>  For SCO OSr5  ELF and Unixware 7 with Native cc

-       makefile.mips    =>  MIPS makefile

-       makefile.acorn   =>  Acorn makefile

-       makefile.amiga   =>  Amiga makefile

-       smakefile.ppc    =>  AMIGA smakefile for SAS C V6.58/7.00 PPC

-                            compiler (Requires SCOPTIONS, copied from

-                            scripts/SCOPTIONS.ppc)

-       makefile.atari   =>  Atari makefile

-       makefile.beos    =>  BEOS makefile for X86

-       makefile.bor     =>  Borland makefile (uses bcc)

-       makefile.bc32    =>  32-bit Borland C++ (all modules compiled in C mode)

-       makefile.tc3     =>  Turbo C 3.0 makefile

-       makefile.dj2     =>  DJGPP 2 makefile

-       makefile.msc     =>  Microsoft C makefile

-       makefile.vcawin32=>  makefile for Microsoft Visual C++ 5.0 and

-                            later (previously used assembler code tuned

-                            for Intel MMX platform)

-       makefile.vcwin32 =>  makefile for Microsoft Visual C++ 4.0 and

-                            later (does not use assembler code)

-       makefile.os2     =>  OS/2 Makefile (gcc and emx, requires pngos2.def)

-       pngos2.def       =>  OS/2 module definition file used by makefile.os2

-       makefile.watcom  =>  Watcom 10a+ Makefile, 32-bit flat memory model

-       makevms.com      =>  VMS build script

-       SCOPTIONS.ppc    =>  Used with smakefile.ppc

-

-Good luck, and happy coding.

-

--Glenn Randers-Pehrson (current maintainer)

- Internet: glennrp at users.sourceforge.net

-

--Andreas Eric Dilger (former maintainer, 1996-1997)

- Internet: adilger at enel.ucalgary.ca

- Web: http://members.shaw.ca/adilger/

-

--Guy Eric Schalnat (original author and former maintainer, 1995-1996)

- (formerly of Group 42, Inc)

- Internet: gschal at infinet.com

+README for libpng version 1.4.0 - January 3, 2010 (shared library 14.0)
+See the note about version numbers near the top of png.h
+
+See INSTALL for instructions on how to install libpng.
+
+Libpng comes in several distribution formats.  Get libpng-*.tar.gz,
+libpng-*.tar.xz or libpng-*.tar.bz2 if you want UNIX-style line endings
+in the text files, or lpng*.zip if you want DOS-style line endings.
+
+Version 0.89 was the first official release of libpng.  Don't let the
+fact that it's the first release fool you.  The libpng library has been in
+extensive use and testing since mid-1995.  By late 1997 it had
+finally gotten to the stage where there hadn't been significant
+changes to the API in some time, and people have a bad feeling about
+libraries with versions < 1.0.  Version 1.0.0 was released in
+March 1998.
+
+****
+Note that some of the changes to the png_info structure render this
+version of the library binary incompatible with libpng-0.89 or
+earlier versions if you are using a shared library.  The type of the
+"filler" parameter for png_set_filler() has changed from png_byte to
+png_uint_32, which will affect shared-library applications that use
+this function.
+
+To avoid problems with changes to the internals of png_info_struct,
+new APIs have been made available in 0.95 to avoid direct application
+access to info_ptr.  These functions are the png_set_<chunk> and
+png_get_<chunk> functions.  These functions should be used when
+accessing/storing the info_struct data, rather than manipulating it
+directly, to avoid such problems in the future.
+
+It is important to note that the APIs do not make current programs
+that access the info struct directly incompatible with the new
+library.  However, it is strongly suggested that new programs use
+the new APIs (as shown in example.c and pngtest.c), and older programs
+be converted to the new format, to facilitate upgrades in the future.
+****
+
+Additions since 0.90 include the ability to compile libpng as a
+Windows DLL, and new APIs for accessing data in the info struct.
+Experimental functions include the ability to set weighting and cost
+factors for row filter selection, direct reads of integers from buffers
+on big-endian processors that support misaligned data access, faster
+methods of doing alpha composition, and more accurate 16->8 bit color
+conversion.
+
+The additions since 0.89 include the ability to read from a PNG stream
+which has had some (or all) of the signature bytes read by the calling
+application.  This also allows the reading of embedded PNG streams that
+do not have the PNG file signature.  As well, it is now possible to set
+the library action on the detection of chunk CRC errors.  It is possible
+to set different actions based on whether the CRC error occurred in a
+critical or an ancillary chunk.
+
+The changes made to the library, and bugs fixed are based on discussions
+on the PNG-implement mailing list and not on material submitted
+privately to Guy, Andreas, or Glenn.  They will forward any good
+suggestions to the list.
+
+For a detailed description on using libpng, read libpng.txt.  For
+examples of libpng in a program, see example.c and pngtest.c.  For usage
+information and restrictions (what little they are) on libpng, see
+png.h.  For a description on using zlib (the compression library used by
+libpng) and zlib's restrictions, see zlib.h
+
+I have included a general makefile, as well as several machine and
+compiler specific ones, but you may have to modify one for your own needs.
+
+You should use zlib 1.0.4 or later to run this, but it MAY work with
+versions as old as zlib 0.95.  Even so, there are bugs in older zlib
+versions which can cause the output of invalid compression streams for
+some images.  You will definitely need zlib 1.0.4 or later if you are
+taking advantage of the MS-DOS "far" structure allocation for the small
+and medium memory models.  You should also note that zlib is a
+compression library that is useful for more things than just PNG files.
+You can use zlib as a drop-in replacement for fread() and fwrite() if
+you are so inclined.
+
+zlib should be available at the same place that libpng is, or at.
+ftp://ftp.info-zip.org/pub/infozip/zlib
+
+You may also want a copy of the PNG specification.  It is available
+as an RFC, a W3C Recommendation, and an ISO/IEC Standard.  You can find
+these at http://www.libpng.org/pub/png/documents/
+
+This code is currently being archived at libpng.sf.net in the
+[DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT)
+at GO GRAPHSUP.  If you can't find it in any of those places,
+e-mail me, and I'll help you find it.
+
+If you have any code changes, requests, problems, etc., please e-mail
+them to me.  Also, I'd appreciate any make files or project files,
+and any modifications you needed to make to get libpng to compile,
+along with a #define variable to tell what compiler/system you are on.
+If you needed to add transformations to libpng, or wish libpng would
+provide the image in a different way, drop me a note (and code, if
+possible), so I can consider supporting the transformation.
+Finally, if you get any warning messages when compiling libpng
+(note: not zlib), and they are easy to fix, I'd appreciate the
+fix.  Please mention "libpng" somewhere in the subject line.  Thanks.
+
+This release was created and will be supported by myself (of course
+based in a large way on Guy's and Andreas' earlier work), and the PNG
+development group.
+
+Send comments/corrections/commendations to png-mng-implement at
+lists.sourceforge.net (subscription required; visit 
+https://lists.sourceforge.net/lists/listinfo/png-mng-implement
+to subscribe) or to glennrp at users.sourceforge.net
+
+You can't reach Guy, the original libpng author, at the addresses
+given in previous versions of this document.  He and Andreas will
+read mail addressed to the png-implement list, however.
+
+Please do not send general questions about PNG.  Send them to
+the (png-list at ccrc.wustl.edu, subscription required, write to
+majordomo at ccrc.wustl.edu with "subscribe png-list" in your message).
+On the other hand,
+please do not send libpng questions to that address, send them to me
+or to the png-implement list.  I'll
+get them in the end anyway.  If you have a question about something
+in the PNG specification that is related to using libpng, send it
+to me.  Send me any questions that start with "I was using libpng,
+and ...".  If in doubt, send questions to me.  I'll bounce them
+to others, if necessary.
+
+Please do not send suggestions on how to change PNG.  We have
+been discussing PNG for nine years now, and it is official and
+finished.  If you have suggestions for libpng, however, I'll
+gladly listen.  Even if your suggestion is not used immediately,
+it may be used later.
+
+Files in this distribution:
+
+      ANNOUNCE      =>  Announcement of this version, with recent changes
+      CHANGES       =>  Description of changes between libpng versions
+      KNOWNBUG      =>  List of known bugs and deficiencies
+      LICENSE       =>  License to use and redistribute libpng
+      README        =>  This file
+      TODO          =>  Things not implemented in the current library
+      Y2KINFO       =>  Statement of Y2K compliance
+      example.c     =>  Example code for using libpng functions
+      libpng.3      =>  manual page for libpng (includes libpng.txt)
+      libpng.txt    =>  Description of libpng and its functions
+      libpngpf.3    =>  manual page for libpng's private functions
+      png.5         =>  manual page for the PNG format
+      png.c         =>  Basic interface functions common to library
+      png.h         =>  Library function and interface declarations
+      pngconf.h     =>  System specific library configuration
+      pngerror.c    =>  Error/warning message I/O functions
+      pngget.c      =>  Functions for retrieving info from struct
+      pngmem.c      =>  Memory handling functions
+      pngbar.png    =>  PNG logo, 88x31
+      pngnow.png    =>  PNG logo, 98x31
+      pngpread.c    =>  Progressive reading functions
+      pngread.c     =>  Read data/helper high-level functions
+      pngrio.c      =>  Lowest-level data read I/O functions
+      pngrtran.c    =>  Read data transformation functions
+      pngrutil.c    =>  Read data utility functions
+      pngset.c      =>  Functions for storing data into the info_struct
+      pngtest.c     =>  Library test program
+      pngtest.png   =>  Library test sample image
+      pngtrans.c    =>  Common data transformation functions
+      pngwio.c      =>  Lowest-level write I/O functions
+      pngwrite.c    =>  High-level write functions
+      pngwtran.c    =>  Write data transformations
+      pngwutil.c    =>  Write utility functions
+      contrib       =>  Contributions
+       gregbook         =>  source code for PNG reading and writing, from
+                            Greg Roelofs' "PNG: The Definitive Guide",
+                            O'Reilly, 1999
+       msvctest     =>  Builds and runs pngtest using a MSVC workspace
+       pngminus     =>  Simple pnm2png and png2pnm programs
+       pngsuite     =>  Test images
+       visupng      =>  Contains a MSVC workspace for VisualPng
+      projects      =>  Contains project files and workspaces for
+                        building a DLL
+       c5builder        =>  Contains a Borland workspace for building
+                            libpng and zlib
+       visualc6         =>  Contains a Microsoft Visual C++ (MSVC)
+                            workspace for building libpng and zlib
+      scripts       =>  Directory containing scripts for building libpng:
+       descrip.mms      =>  VMS makefile for MMS or MMK
+       makefile.std     =>  Generic UNIX makefile (cc, creates static
+                            libpng.a)
+       makefile.elf     =>  Linux/ELF makefile symbol versioning,
+                            gcc, creates libpng14.so.14.1.4.0)
+       makefile.linux   =>  Linux/ELF makefile
+                            (gcc, creates libpng14.so.14.1.4.0)
+       makefile.gcc     =>  Generic makefile (gcc, creates static libpng.a)
+       makefile.knr     =>  Archaic UNIX Makefile that converts files with
+                            ansi2knr (Requires ansi2knr.c from
+                            ftp://ftp.cs.wisc.edu/ghost)
+       makefile.aix     =>  AIX makefile
+       makefile.cygwin  =>  Cygwin/gcc makefile
+       makefile.darwin  =>  Darwin makefile
+       makefile.dec     =>  DEC Alpha UNIX makefile
+       makefile.freebsd =>  FreeBSD makefile
+       makefile.hpgcc   =>  HPUX makefile using gcc
+       makefile.hpux    =>  HPUX (10.20 and 11.00) makefile
+       makefile.hp64    =>  HPUX (10.20 and 11.00) makefile, 64 bit
+       makefile.ibmc    =>  IBM C/C++ version 3.x for Win32 and OS/2 (static)
+       makefile.intel   =>  Intel C/C++ version 4.0 and later
+       makefile.mingw   =>  Mingw/gcc makefile
+       makefile.netbsd  =>  NetBSD/cc makefile, makes libpng.so.
+       makefile.ne14bsd  =>  NetBSD/cc makefile, makes
+                            libpng14.so
+       makefile.openbsd =>  OpenBSD makefile
+       makefile.sgi     =>  Silicon Graphics IRIX (cc, creates static lib)
+       makefile.sggcc   =>  Silicon Graphics
+                            (gcc, creates libpng14.so.14.1.4.0)
+       makefile.sunos   =>  Sun makefile
+       makefile.solaris =>  Solaris 2.X makefile
+                            (gcc, creates libpng14.so.14.1.4.0)
+       makefile.so9     =>  Solaris 9 makefile
+                            (gcc, creates libpng14.so.14.1.4.0)
+       makefile.32sunu  =>  Sun Ultra 32-bit makefile
+       makefile.64sunu  =>  Sun Ultra 64-bit makefile
+       makefile.sco     =>  For SCO OSr5  ELF and Unixware 7 with Native cc
+       makefile.mips    =>  MIPS makefile
+       makefile.acorn   =>  Acorn makefile
+       makefile.amiga   =>  Amiga makefile
+       smakefile.ppc    =>  AMIGA smakefile for SAS C V6.58/7.00 PPC
+                            compiler (Requires SCOPTIONS, copied from
+                            scripts/SCOPTIONS.ppc)
+       makefile.atari   =>  Atari makefile
+       makefile.beos    =>  BEOS makefile for X86
+       makefile.bor     =>  Borland makefile (uses bcc)
+       makefile.bc32    =>  32-bit Borland C++ (all modules compiled in C mode)
+       makefile.tc3     =>  Turbo C 3.0 makefile
+       makefile.dj2     =>  DJGPP 2 makefile
+       makefile.msc     =>  Microsoft C makefile
+       makefile.vcwin32 =>  makefile for Microsoft Visual C++ 4.0 and
+                            later (does not use assembler code)
+       makefile.os2     =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
+       png32ce.def      =>  module definition for makefile.cegccg
+       pngos2.def       =>  OS/2 module definition file used by
+                            makefile.os2
+       pngwin.def       =>  module definition file used by
+                            makefile.cygwin and makefile.mingw
+       makefile.watcom  =>  Watcom 10a+ Makefile, 32-bit flat memory model
+       makevms.com      =>  VMS build script
+       SCOPTIONS.ppc    =>  Used with smakefile.ppc
+
+Good luck, and happy coding.
+
+-Glenn Randers-Pehrson (current maintainer, since 1998)
+ Internet: glennrp at users.sourceforge.net
+
+-Andreas Eric Dilger (former maintainer, 1996-1997)
+ Internet: adilger at enel.ucalgary.ca
+ Web: http://www-mddsp.enel.ucalgary.ca/People/adilger/
+
+-Guy Eric Schalnat (original author and former maintainer, 1995-1996)
+ (formerly of Group 42, Inc)
+ Internet: gschal at infinet.com
diff --git a/src/libpng/libpng.vcproj b/src/libpng/libpng.vcproj
index 27a445c66..5137f8bf9 100644
--- a/src/libpng/libpng.vcproj
+++ b/src/libpng/libpng.vcproj
@@ -287,10 +287,6 @@
 				>

 			</File>

 			<File

-				RelativePath=".\pnggccrd.c"

-				>

-			</File>

-			<File

 				RelativePath=".\pngget.c"

 				>

 			</File>

diff --git a/src/libpng/png.c b/src/libpng/png.c
index 6fbb1d611..a845a4783 100644
--- a/src/libpng/png.c
+++ b/src/libpng/png.c
@@ -1,1099 +1,916 @@
-

-/* png.c - location for general purpose libpng functions

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_EXTERN

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-

-/* Generate a compiler error if there is an old png.h in the search path. */

-typedef version_1_2_41 Your_png_h_is_not_version_1_2_41;

-

-/* Version information for C files.  This had better match the version

- * string defined in png.h.

- */

-

-#ifdef PNG_USE_GLOBAL_ARRAYS

-/* png_libpng_ver was changed to a function in version 1.0.5c */

-PNG_CONST char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;

-

-#ifdef PNG_READ_SUPPORTED

-

-/* png_sig was changed to a function in version 1.0.5c */

-/* Place to hold the signature string for a PNG file. */

-PNG_CONST png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};

-#endif /* PNG_READ_SUPPORTED */

-

-/* Invoke global declarations for constant strings for known chunk types */

-PNG_IHDR;

-PNG_IDAT;

-PNG_IEND;

-PNG_PLTE;

-PNG_bKGD;

-PNG_cHRM;

-PNG_gAMA;

-PNG_hIST;

-PNG_iCCP;

-PNG_iTXt;

-PNG_oFFs;

-PNG_pCAL;

-PNG_sCAL;

-PNG_pHYs;

-PNG_sBIT;

-PNG_sPLT;

-PNG_sRGB;

-PNG_tEXt;

-PNG_tIME;

-PNG_tRNS;

-PNG_zTXt;

-

-#ifdef PNG_READ_SUPPORTED

-/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-

-/* Start of interlace block */

-PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};

-

-/* Offset to next interlace block */

-PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};

-

-/* Start of interlace block in the y direction */

-PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};

-

-/* Offset to next interlace block in the y direction */

-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

- * it, uncomment it here and in png.h

-PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};

-*/

-

-/* Mask to determine which pixels are valid in a pass */

-PNG_CONST int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

-

-/* Mask to determine which pixels to overwrite while displaying */

-PNG_CONST int FARDATA png_pass_dsp_mask[]

-   = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

-

-#endif /* PNG_READ_SUPPORTED */

-#endif /* PNG_USE_GLOBAL_ARRAYS */

-

-/* Tells libpng that we have already handled the first "num_bytes" bytes

- * of the PNG file signature.  If the PNG data is embedded into another

- * stream we can set num_bytes = 8 so that libpng will not attempt to read

- * or write any of the magic bytes before it starts on the IHDR.

- */

-

-#ifdef PNG_READ_SUPPORTED

-void PNGAPI

-png_set_sig_bytes(png_structp png_ptr, int num_bytes)

-{

-   png_debug(1, "in png_set_sig_bytes");

-

-   if (png_ptr == NULL)

-      return;

-

-   if (num_bytes > 8)

-      png_error(png_ptr, "Too many bytes for PNG signature.");

-

-   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);

-}

-

-/* Checks whether the supplied bytes match the PNG signature.  We allow

- * checking less than the full 8-byte signature so that those apps that

- * already read the first few bytes of a file to determine the file type

- * can simply check the remaining bytes for extra assurance.  Returns

- * an integer less than, equal to, or greater than zero if sig is found,

- * respectively, to be less than, to match, or be greater than the correct

- * PNG signature (this is the same behaviour as strcmp, memcmp, etc).

- */

-int PNGAPI

-png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)

-{

-   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

-   if (num_to_check > 8)

-      num_to_check = 8;

-   else if (num_to_check < 1)

-      return (-1);

-

-   if (start > 7)

-      return (-1);

-

-   if (start + num_to_check > 8)

-      num_to_check = 8 - start;

-

-   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));

-}

-

-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

-/* (Obsolete) function to check signature bytes.  It does not allow one

- * to check a partial signature.  This function might be removed in the

- * future - use png_sig_cmp().  Returns true (nonzero) if the file is PNG.

- */

-int PNGAPI

-png_check_sig(png_bytep sig, int num)

-{

-  return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));

-}

-#endif

-#endif /* PNG_READ_SUPPORTED */

-

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-/* Function to allocate memory for zlib and clear it to 0. */

-#ifdef PNG_1_0_X

-voidpf PNGAPI

-#else

-voidpf /* PRIVATE */

-#endif

-png_zalloc(voidpf png_ptr, uInt items, uInt size)

-{

-   png_voidp ptr;

-   png_structp p=(png_structp)png_ptr;

-   png_uint_32 save_flags=p->flags;

-   png_uint_32 num_bytes;

-

-   if (png_ptr == NULL)

-      return (NULL);

-   if (items > PNG_UINT_32_MAX/size)

-   {

-     png_warning (p, "Potential overflow in png_zalloc()");

-     return (NULL);

-   }

-   num_bytes = (png_uint_32)items * size;

-

-   p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;

-   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);

-   p->flags=save_flags;

-

-#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)

-   if (ptr == NULL)

-       return ((voidpf)ptr);

-

-   if (num_bytes > (png_uint_32)0x8000L)

-   {

-      png_memset(ptr, 0, (png_size_t)0x8000L);

-      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,

-         (png_size_t)(num_bytes - (png_uint_32)0x8000L));

-   }

-   else

-   {

-      png_memset(ptr, 0, (png_size_t)num_bytes);

-   }

-#endif

-   return ((voidpf)ptr);

-}

-

-/* Function to free memory for zlib */

-#ifdef PNG_1_0_X

-void PNGAPI

-#else

-void /* PRIVATE */

-#endif

-png_zfree(voidpf png_ptr, voidpf ptr)

-{

-   png_free((png_structp)png_ptr, (png_voidp)ptr);

-}

-

-/* Reset the CRC variable to 32 bits of 1's.  Care must be taken

- * in case CRC is > 32 bits to leave the top bits 0.

- */

-void /* PRIVATE */

-png_reset_crc(png_structp png_ptr)

-{

-   png_ptr->crc = crc32(0, Z_NULL, 0);

-}

-

-/* Calculate the CRC over a section of data.  We can only pass as

- * much data to this routine as the largest single buffer size.  We

- * also check that this data will actually be used before going to the

- * trouble of calculating it.

- */

-void /* PRIVATE */

-png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)

-{

-   int need_crc = 1;

-

-   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */

-   {

-      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

-          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

-         need_crc = 0;

-   }

-   else                                                    /* critical */

-   {

-      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

-         need_crc = 0;

-   }

-

-   if (need_crc)

-      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);

-}

-

-/* Allocate the memory for an info_struct for the application.  We don't

- * really need the png_ptr, but it could potentially be useful in the

- * future.  This should be used in favour of malloc(png_sizeof(png_info))

- * and png_info_init() so that applications that want to use a shared

- * libpng don't have to be recompiled if png_info changes size.

- */

-png_infop PNGAPI

-png_create_info_struct(png_structp png_ptr)

-{

-   png_infop info_ptr;

-

-   png_debug(1, "in png_create_info_struct");

-

-   if (png_ptr == NULL)

-      return (NULL);

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,

-      png_ptr->malloc_fn, png_ptr->mem_ptr);

-#else

-   info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);

-#endif

-   if (info_ptr != NULL)

-      png_info_init_3(&info_ptr, png_sizeof(png_info));

-

-   return (info_ptr);

-}

-

-/* This function frees the memory associated with a single info struct.

- * Normally, one would use either png_destroy_read_struct() or

- * png_destroy_write_struct() to free an info struct, but this may be

- * useful for some applications.

- */

-void PNGAPI

-png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)

-{

-   png_infop info_ptr = NULL;

-

-   png_debug(1, "in png_destroy_info_struct");

-

-   if (png_ptr == NULL)

-      return;

-

-   if (info_ptr_ptr != NULL)

-      info_ptr = *info_ptr_ptr;

-

-   if (info_ptr != NULL)

-   {

-      png_info_destroy(png_ptr, info_ptr);

-

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,

-          png_ptr->mem_ptr);

-#else

-      png_destroy_struct((png_voidp)info_ptr);

-#endif

-      *info_ptr_ptr = NULL;

-   }

-}

-

-/* Initialize the info structure.  This is now an internal function (0.89)

- * and applications using it are urged to use png_create_info_struct()

- * instead.

- */

-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

-#undef png_info_init

-void PNGAPI

-png_info_init(png_infop info_ptr)

-{

-   /* We only come here via pre-1.0.12-compiled applications */

-   png_info_init_3(&info_ptr, 0);

-}

-#endif

-

-void PNGAPI

-png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)

-{

-   png_infop info_ptr = *ptr_ptr;

-

-   png_debug(1, "in png_info_init_3");

-

-   if (info_ptr == NULL)

-      return;

-

-   if (png_sizeof(png_info) > png_info_struct_size)

-   {

-      png_destroy_struct(info_ptr);

-      info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);

-      *ptr_ptr = info_ptr;

-   }

-

-   /* Set everything to 0 */

-   png_memset(info_ptr, 0, png_sizeof(png_info));

-}

-

-#ifdef PNG_FREE_ME_SUPPORTED

-void PNGAPI

-png_data_freer(png_structp png_ptr, png_infop info_ptr,

-   int freer, png_uint_32 mask)

-{

-   png_debug(1, "in png_data_freer");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   if (freer == PNG_DESTROY_WILL_FREE_DATA)

-      info_ptr->free_me |= mask;

-   else if (freer == PNG_USER_WILL_FREE_DATA)

-      info_ptr->free_me &= ~mask;

-   else

-      png_warning(png_ptr,

-         "Unknown freer parameter in png_data_freer.");

-}

-#endif

-

-void PNGAPI

-png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,

-   int num)

-{

-   png_debug(1, "in png_free_data");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-#ifdef PNG_TEXT_SUPPORTED

-   /* Free text item num or (if num == -1) all text items */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)

-#else

-   if (mask & PNG_FREE_TEXT)

-#endif

-   {

-      if (num != -1)

-      {

-         if (info_ptr->text && info_ptr->text[num].key)

-         {

-            png_free(png_ptr, info_ptr->text[num].key);

-            info_ptr->text[num].key = NULL;

-         }

-      }

-      else

-      {

-         int i;

-         for (i = 0; i < info_ptr->num_text; i++)

-             png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);

-         png_free(png_ptr, info_ptr->text);

-         info_ptr->text = NULL;

-         info_ptr->num_text=0;

-      }

-   }

-#endif

-

-#ifdef PNG_tRNS_SUPPORTED

-   /* Free any tRNS entry */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)

-#else

-   if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))

-#endif

-   {

-      png_free(png_ptr, info_ptr->trans);

-      info_ptr->trans = NULL;

-      info_ptr->valid &= ~PNG_INFO_tRNS;

-#ifndef PNG_FREE_ME_SUPPORTED

-      png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;

-#endif

-   }

-#endif

-

-#ifdef PNG_sCAL_SUPPORTED

-   /* Free any sCAL entry */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)

-#else

-   if (mask & PNG_FREE_SCAL)

-#endif

-   {

-#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_height);

-      info_ptr->scal_s_width = NULL;

-      info_ptr->scal_s_height = NULL;

-#endif

-      info_ptr->valid &= ~PNG_INFO_sCAL;

-   }

-#endif

-

-#ifdef PNG_pCAL_SUPPORTED

-   /* Free any pCAL entry */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)

-#else

-   if (mask & PNG_FREE_PCAL)

-#endif

-   {

-      png_free(png_ptr, info_ptr->pcal_purpose);

-      png_free(png_ptr, info_ptr->pcal_units);

-      info_ptr->pcal_purpose = NULL;

-      info_ptr->pcal_units = NULL;

-      if (info_ptr->pcal_params != NULL)

-         {

-            int i;

-            for (i = 0; i < (int)info_ptr->pcal_nparams; i++)

-            {

-               png_free(png_ptr, info_ptr->pcal_params[i]);

-               info_ptr->pcal_params[i]=NULL;

-            }

-            png_free(png_ptr, info_ptr->pcal_params);

-            info_ptr->pcal_params = NULL;

-         }

-      info_ptr->valid &= ~PNG_INFO_pCAL;

-   }

-#endif

-

-#ifdef PNG_iCCP_SUPPORTED

-   /* Free any iCCP entry */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)

-#else

-   if (mask & PNG_FREE_ICCP)

-#endif

-   {

-      png_free(png_ptr, info_ptr->iccp_name);

-      png_free(png_ptr, info_ptr->iccp_profile);

-      info_ptr->iccp_name = NULL;

-      info_ptr->iccp_profile = NULL;

-      info_ptr->valid &= ~PNG_INFO_iCCP;

-   }

-#endif

-

-#ifdef PNG_sPLT_SUPPORTED

-   /* Free a given sPLT entry, or (if num == -1) all sPLT entries */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)

-#else

-   if (mask & PNG_FREE_SPLT)

-#endif

-   {

-      if (num != -1)

-      {

-         if (info_ptr->splt_palettes)

-         {

-            png_free(png_ptr, info_ptr->splt_palettes[num].name);

-            png_free(png_ptr, info_ptr->splt_palettes[num].entries);

-            info_ptr->splt_palettes[num].name = NULL;

-            info_ptr->splt_palettes[num].entries = NULL;

-         }

-      }

-      else

-      {

-         if (info_ptr->splt_palettes_num)

-         {

-            int i;

-            for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)

-               png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);

-

-            png_free(png_ptr, info_ptr->splt_palettes);

-            info_ptr->splt_palettes = NULL;

-            info_ptr->splt_palettes_num = 0;

-         }

-         info_ptr->valid &= ~PNG_INFO_sPLT;

-      }

-   }

-#endif

-

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-   if (png_ptr->unknown_chunk.data)

-   {

-      png_free(png_ptr, png_ptr->unknown_chunk.data);

-      png_ptr->unknown_chunk.data = NULL;

-   }

-

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)

-#else

-   if (mask & PNG_FREE_UNKN)

-#endif

-   {

-      if (num != -1)

-      {

-          if (info_ptr->unknown_chunks)

-          {

-             png_free(png_ptr, info_ptr->unknown_chunks[num].data);

-             info_ptr->unknown_chunks[num].data = NULL;

-          }

-      }

-      else

-      {

-         int i;

-

-         if (info_ptr->unknown_chunks_num)

-         {

-            for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)

-               png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);

-

-            png_free(png_ptr, info_ptr->unknown_chunks);

-            info_ptr->unknown_chunks = NULL;

-            info_ptr->unknown_chunks_num = 0;

-         }

-      }

-   }

-#endif

-

-#ifdef PNG_hIST_SUPPORTED

-   /* Free any hIST entry */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)

-#else

-   if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))

-#endif

-   {

-      png_free(png_ptr, info_ptr->hist);

-      info_ptr->hist = NULL;

-      info_ptr->valid &= ~PNG_INFO_hIST;

-#ifndef PNG_FREE_ME_SUPPORTED

-      png_ptr->flags &= ~PNG_FLAG_FREE_HIST;

-#endif

-   }

-#endif

-

-   /* Free any PLTE entry that was internally allocated */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)

-#else

-   if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))

-#endif

-   {

-      png_zfree(png_ptr, info_ptr->palette);

-      info_ptr->palette = NULL;

-      info_ptr->valid &= ~PNG_INFO_PLTE;

-#ifndef PNG_FREE_ME_SUPPORTED

-      png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;

-#endif

-      info_ptr->num_palette = 0;

-   }

-

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-   /* Free any image bits attached to the info structure */

-#ifdef PNG_FREE_ME_SUPPORTED

-   if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)

-#else

-   if (mask & PNG_FREE_ROWS)

-#endif

-   {

-      if (info_ptr->row_pointers)

-      {

-         int row;

-         for (row = 0; row < (int)info_ptr->height; row++)

-         {

-            png_free(png_ptr, info_ptr->row_pointers[row]);

-            info_ptr->row_pointers[row]=NULL;

-         }

-         png_free(png_ptr, info_ptr->row_pointers);

-         info_ptr->row_pointers=NULL;

-      }

-      info_ptr->valid &= ~PNG_INFO_IDAT;

-   }

-#endif

-

-#ifdef PNG_FREE_ME_SUPPORTED

-   if (num == -1)

-      info_ptr->free_me &= ~mask;

-   else

-      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);

-#endif

-}

-

-/* This is an internal routine to free any memory that the info struct is

- * pointing to before re-using it or freeing the struct itself.  Recall

- * that png_free() checks for NULL pointers for us.

- */

-void /* PRIVATE */

-png_info_destroy(png_structp png_ptr, png_infop info_ptr)

-{

-   png_debug(1, "in png_info_destroy");

-

-   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

-

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-   if (png_ptr->num_chunk_list)

-   {

-      png_free(png_ptr, png_ptr->chunk_list);

-      png_ptr->chunk_list=NULL;

-      png_ptr->num_chunk_list = 0;

-   }

-#endif

-

-   png_info_init_3(&info_ptr, png_sizeof(png_info));

-}

-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

-

-/* This function returns a pointer to the io_ptr associated with the user

- * functions.  The application should free any memory associated with this

- * pointer before png_write_destroy() or png_read_destroy() are called.

- */

-png_voidp PNGAPI

-png_get_io_ptr(png_structp png_ptr)

-{

-   if (png_ptr == NULL)

-      return (NULL);

-   return (png_ptr->io_ptr);

-}

-

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-#ifdef PNG_STDIO_SUPPORTED

-/* Initialize the default input/output functions for the PNG file.  If you

- * use your own read or write routines, you can call either png_set_read_fn()

- * or png_set_write_fn() instead of png_init_io().  If you have defined

- * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't

- * necessarily available.

- */

-void PNGAPI

-png_init_io(png_structp png_ptr, png_FILE_p fp)

-{

-   png_debug(1, "in png_init_io");

-

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->io_ptr = (png_voidp)fp;

-}

-#endif

-

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-/* Convert the supplied time into an RFC 1123 string suitable for use in

- * a "Creation Time" or other text-based time string.

- */

-png_charp PNGAPI

-png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)

-{

-   static PNG_CONST char short_months[12][4] =

-        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",

-         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

-

-   if (png_ptr == NULL)

-      return (NULL);

-   if (png_ptr->time_buffer == NULL)

-   {

-      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*

-         png_sizeof(char)));

-   }

-

-#ifdef _WIN32_WCE

-   {

-      wchar_t time_buf[29];

-      wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),

-          ptime->day % 32, short_months[(ptime->month - 1) % 12],

-        ptime->year, ptime->hour % 24, ptime->minute % 60,

-          ptime->second % 61);

-      WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,

-          NULL, NULL);

-   }

-#else

-#ifdef USE_FAR_KEYWORD

-   {

-      char near_time_buf[29];

-      png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",

-          ptime->day % 32, short_months[(ptime->month - 1) % 12],

-          ptime->year, ptime->hour % 24, ptime->minute % 60,

-          ptime->second % 61);

-      png_memcpy(png_ptr->time_buffer, near_time_buf,

-          29*png_sizeof(char));

-   }

-#else

-   png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",

-       ptime->day % 32, short_months[(ptime->month - 1) % 12],

-       ptime->year, ptime->hour % 24, ptime->minute % 60,

-       ptime->second % 61);

-#endif

-#endif /* _WIN32_WCE */

-   return ((png_charp)png_ptr->time_buffer);

-}

-#endif /* PNG_TIME_RFC1123_SUPPORTED */

-

-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

-

-png_charp PNGAPI

-png_get_copyright(png_structp png_ptr)

-{

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

-#ifdef PNG_STRING_COPYRIGHT

-      return PNG_STRING_COPYRIGHT

-#else

-#ifdef __STDC__

-   return ((png_charp) PNG_STRING_NEWLINE \

-     "libpng version 1.2.41 - December 3, 2009" PNG_STRING_NEWLINE \

-     "Copyright (c) 1998-2009 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \

-     "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \

-     "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \

-     PNG_STRING_NEWLINE);

-#else

-      return ((png_charp) "libpng version 1.2.41 - December 3, 2009\

-      Copyright (c) 1998-2009 Glenn Randers-Pehrson\

-      Copyright (c) 1996-1997 Andreas Dilger\

-      Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.");

-#endif

-#endif

-}

-

-/* The following return the library version as a short string in the

- * format 1.0.0 through 99.99.99zz.  To get the version of *.h files

- * used with your application, print out PNG_LIBPNG_VER_STRING, which

- * is defined in png.h.

- * Note: now there is no difference between png_get_libpng_ver() and

- * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,

- * it is guaranteed that png.c uses the correct version of png.h.

- */

-png_charp PNGAPI

-png_get_libpng_ver(png_structp png_ptr)

-{

-   /* Version of *.c files used when building libpng */

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

-   return ((png_charp) PNG_LIBPNG_VER_STRING);

-}

-

-png_charp PNGAPI

-png_get_header_ver(png_structp png_ptr)

-{

-   /* Version of *.h files used when building libpng */

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

-   return ((png_charp) PNG_LIBPNG_VER_STRING);

-}

-

-png_charp PNGAPI

-png_get_header_version(png_structp png_ptr)

-{

-   /* Returns longer string containing both version and date */

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

-#ifdef __STDC__

-   return ((png_charp) PNG_HEADER_VERSION_STRING

-#ifndef PNG_READ_SUPPORTED

-   "     (NO READ SUPPORT)"

-#endif

-   PNG_STRING_NEWLINE);

-#else

-   return ((png_charp) PNG_HEADER_VERSION_STRING);

-#endif

-}

-

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-int PNGAPI

-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 */

-   int i;

-   png_bytep p;

-   if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)

-      return 0;

-   p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;

-   for (i = png_ptr->num_chunk_list; i; i--, p -= 5)

-      if (!png_memcmp(chunk_name, p, 4))

-        return ((int)*(p + 4));

-   return 0;

-}

-#endif

-

-/* This function, added to libpng-1.0.6g, is untested. */

-int PNGAPI

-png_reset_zstream(png_structp png_ptr)

-{

-   if (png_ptr == NULL)

-      return Z_STREAM_ERROR;

-   return (inflateReset(&png_ptr->zstream));

-}

-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

-

-/* This function was added to libpng-1.0.7 */

-png_uint_32 PNGAPI

-png_access_version_number(void)

-{

-   /* Version of *.c files used when building libpng */

-   return((png_uint_32) PNG_LIBPNG_VER);

-}

-

-

-#if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED)

-#ifndef PNG_1_0_X

-/* This function was added to libpng 1.2.0 */

-int PNGAPI

-png_mmx_support(void)

-{

-   /* Obsolete, to be removed from libpng-1.4.0 */

-    return -1;

-}

-#endif /* PNG_1_0_X */

-#endif /* PNG_READ_SUPPORTED && PNG_ASSEMBLER_CODE_SUPPORTED */

-

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-#ifdef PNG_SIZE_T

-/* Added at libpng version 1.2.6 */

-   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));

-png_size_t PNGAPI

-png_convert_size(size_t size)

-{

-   if (size > (png_size_t)-1)

-      PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */

-   return ((png_size_t)size);

-}

-#endif /* PNG_SIZE_T */

-

-/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */

-#ifdef PNG_cHRM_SUPPORTED

-#ifdef PNG_CHECK_cHRM_SUPPORTED

-

-/*

- *    Multiply two 32-bit numbers, V1 and V2, using 32-bit

- *    arithmetic, to produce a 64 bit result in the HI/LO words.

- *

- *                  A B

- *                x C D

- *               ------

- *              AD || BD

- *        AC || CB || 0

- *

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

- *    A and D, and X || Y is (X << 16) + Y.

-*/

-

-void /* PRIVATE */

-png_64bit_product (long v1, long v2, unsigned long *hi_product,

-   unsigned long *lo_product)

-{

-   int a, b, c, d;

-   long lo, hi, x, y;

-

-   a = (v1 >> 16) & 0xffff;

-   b = v1 & 0xffff;

-   c = (v2 >> 16) & 0xffff;

-   d = v2 & 0xffff;

-

-   lo = b * d;                   /* BD */

-   x = a * d + c * b;            /* AD + CB */

-   y = ((lo >> 16) & 0xffff) + x;

-

-   lo = (lo & 0xffff) | ((y & 0xffff) << 16);

-   hi = (y >> 16) & 0xffff;

-

-   hi += a * c;                  /* AC */

-

-   *hi_product = (unsigned long)hi;

-   *lo_product = (unsigned long)lo;

-}

-

-int /* PRIVATE */

-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 red_y, png_fixed_point green_x, png_fixed_point green_y,

-   png_fixed_point blue_x, png_fixed_point blue_y)

-{

-   int ret = 1;

-   unsigned long xy_hi,xy_lo,yx_hi,yx_lo;

-

-   png_debug(1, "in function png_check_cHRM_fixed");

-

-   if (png_ptr == NULL)

-      return 0;

-

-   if (white_x < 0 || white_y <= 0 ||

-         red_x < 0 ||   red_y <  0 ||

-       green_x < 0 || green_y <  0 ||

-        blue_x < 0 ||  blue_y <  0)

-   {

-      png_warning(png_ptr,

-        "Ignoring attempt to set negative chromaticity value");

-      ret = 0;

-   }

-   if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||

-       white_y > (png_fixed_point) PNG_UINT_31_MAX ||

-         red_x > (png_fixed_point) PNG_UINT_31_MAX ||

-         red_y > (png_fixed_point) PNG_UINT_31_MAX ||

-       green_x > (png_fixed_point) PNG_UINT_31_MAX ||

-       green_y > (png_fixed_point) PNG_UINT_31_MAX ||

-        blue_x > (png_fixed_point) PNG_UINT_31_MAX ||

-        blue_y > (png_fixed_point) PNG_UINT_31_MAX )

-   {

-      png_warning(png_ptr,

-        "Ignoring attempt to set chromaticity value exceeding 21474.83");

-      ret = 0;

-   }

-   if (white_x > 100000L - white_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM white point");

-      ret = 0;

-   }

-   if (red_x > 100000L - red_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM red point");

-      ret = 0;

-   }

-   if (green_x > 100000L - green_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM green point");

-      ret = 0;

-   }

-   if (blue_x > 100000L - blue_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM blue point");

-      ret = 0;

-   }

-

-   png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);

-   png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);

-

-   if (xy_hi == yx_hi && xy_lo == yx_lo)

-   {

-      png_warning(png_ptr,

-         "Ignoring attempt to set cHRM RGB triangle with zero area");

-      ret = 0;

-   }

-

-   return ret;

-}

-#endif /* PNG_CHECK_cHRM_SUPPORTED */

-#endif /* PNG_cHRM_SUPPORTED */

-

-void /* PRIVATE */

-png_check_IHDR(png_structp png_ptr,

-   png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_type, int compression_type,

-   int filter_type)

-{

-   int error = 0;

-

-   /* Check for width and height valid values */

-   if (width == 0)

-   {

-      png_warning(png_ptr, "Image width is zero in IHDR");

-      error = 1;

-   }

-

-   if (height == 0)

-   {

-      png_warning(png_ptr, "Image height is zero in IHDR");

-      error = 1;

-   }

-

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX)

-#else

-   if (width > PNG_USER_WIDTH_MAX)

-#endif

-   {

-      png_warning(png_ptr, "Image width exceeds user limit in IHDR");

-      error = 1;

-   }

-

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX)

-#else

-   if (height > PNG_USER_HEIGHT_MAX)

-#endif

-   {

-      png_warning(png_ptr, "Image height exceeds user limit in IHDR");

-      error = 1;

-   }

-

-   if (width > PNG_UINT_31_MAX)

-   {

-      png_warning(png_ptr, "Invalid image width in IHDR");

-      error = 1;

-   }

-

-   if ( height > PNG_UINT_31_MAX)

-   {

-      png_warning(png_ptr, "Invalid image height in IHDR");

-      error = 1;

-   }

-

-   if ( width > (PNG_UINT_32_MAX

-                 >> 3)      /* 8-byte RGBA pixels */

-                 - 64       /* bigrowbuf hack */

-                 - 1        /* filter byte */

-                 - 7*8      /* rounding of width to multiple of 8 pixels */

-                 - 8)       /* extra max_pixel_depth pad */

-      png_warning(png_ptr, "Width is too large for libpng to process pixels");

-

-   /* Check other values */

-   if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&

-       bit_depth != 8 && bit_depth != 16)

-   {

-      png_warning(png_ptr, "Invalid bit depth in IHDR");

-      error = 1;

-   }

-

-   if (color_type < 0 || color_type == 1 ||

-       color_type == 5 || color_type > 6)

-   {

-      png_warning(png_ptr, "Invalid color type in IHDR");

-      error = 1;

-   }

-

-   if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||

-       ((color_type == PNG_COLOR_TYPE_RGB ||

-         color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||

-         color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))

-   {

-      png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");

-      error = 1;

-   }

-

-   if (interlace_type >= PNG_INTERLACE_LAST)

-   {

-      png_warning(png_ptr, "Unknown interlace method in IHDR");

-      error = 1;

-   }

-

-   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Unknown compression method in IHDR");

-      error = 1;

-   }

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   /* Accept filter_method 64 (intrapixel differencing) only if

-    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

-    * 2. Libpng did not read a PNG signature (this filter_method is only

-    *    used in PNG datastreams that are embedded in MNG datastreams) and

-    * 3. The application called png_permit_mng_features with a mask that

-    *    included PNG_FLAG_MNG_FILTER_64 and

-    * 4. The filter_method is 64 and

-    * 5. The color_type is RGB or RGBA

-    */

-   if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&

-       png_ptr->mng_features_permitted)

-      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");

-

-   if (filter_type != PNG_FILTER_TYPE_BASE)

-   {

-      if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

-         (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&

-         ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&

-         (color_type == PNG_COLOR_TYPE_RGB ||

-         color_type == PNG_COLOR_TYPE_RGB_ALPHA)))

-      {

-         png_warning(png_ptr, "Unknown filter method in IHDR");

-         error = 1;

-      }

-

-      if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)

-      {

-         png_warning(png_ptr, "Invalid filter method in IHDR");

-         error = 1;

-      }

-   }

-

-#else

-   if (filter_type != PNG_FILTER_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Unknown filter method in IHDR");

-      error = 1;

-   }

-#endif

-

-   if (error == 1)

-      png_error(png_ptr, "Invalid IHDR data");

-}

-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

+
+/* png.c - location for general purpose libpng functions
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_NO_EXTERN
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#include "pngpriv.h"
+
+/* Generate a compiler error if there is an old png.h in the search path. */
+typedef version_1_4_0 Your_png_h_is_not_version_1_4_0;
+
+/* Version information for C files.  This had better match the version
+ * string defined in png.h.
+ */
+
+/* Tells libpng that we have already handled the first "num_bytes" bytes
+ * of the PNG file signature.  If the PNG data is embedded into another
+ * stream we can set num_bytes = 8 so that libpng will not attempt to read
+ * or write any of the magic bytes before it starts on the IHDR.
+ */
+
+#ifdef PNG_READ_SUPPORTED
+void PNGAPI
+png_set_sig_bytes(png_structp png_ptr, int num_bytes)
+{
+   png_debug(1, "in png_set_sig_bytes");
+
+   if (png_ptr == NULL)
+      return;
+
+   if (num_bytes > 8)
+      png_error(png_ptr, "Too many bytes for PNG signature");
+
+   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
+}
+
+/* Checks whether the supplied bytes match the PNG signature.  We allow
+ * checking less than the full 8-byte signature so that those apps that
+ * already read the first few bytes of a file to determine the file type
+ * can simply check the remaining bytes for extra assurance.  Returns
+ * an integer less than, equal to, or greater than zero if sig is found,
+ * respectively, to be less than, to match, or be greater than the correct
+ * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
+ */
+int PNGAPI
+png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
+{
+   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+   if (num_to_check > 8)
+      num_to_check = 8;
+   else if (num_to_check < 1)
+      return (-1);
+
+   if (start > 7)
+      return (-1);
+
+   if (start + num_to_check > 8)
+      num_to_check = 8 - start;
+
+   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
+}
+
+#endif /* PNG_READ_SUPPORTED */
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+/* Function to allocate memory for zlib and clear it to 0. */
+voidpf /* PRIVATE */
+png_zalloc(voidpf png_ptr, uInt items, uInt size)
+{
+   png_voidp ptr;
+   png_structp p=(png_structp)png_ptr;
+   png_uint_32 save_flags=p->flags;
+   png_alloc_size_t num_bytes;
+
+   if (png_ptr == NULL)
+      return (NULL);
+   if (items > PNG_UINT_32_MAX/size)
+   {
+     png_warning (p, "Potential overflow in png_zalloc()");
+     return (NULL);
+   }
+   num_bytes = (png_alloc_size_t)items * size;
+
+   p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
+   p->flags=save_flags;
+
+   return ((voidpf)ptr);
+}
+
+/* Function to free memory for zlib */
+void /* PRIVATE */
+png_zfree(voidpf png_ptr, voidpf ptr)
+{
+   png_free((png_structp)png_ptr, (png_voidp)ptr);
+}
+
+/* Reset the CRC variable to 32 bits of 1's.  Care must be taken
+ * in case CRC is > 32 bits to leave the top bits 0.
+ */
+void /* PRIVATE */
+png_reset_crc(png_structp png_ptr)
+{
+   png_ptr->crc = crc32(0, Z_NULL, 0);
+}
+
+/* Calculate the CRC over a section of data.  We can only pass as
+ * much data to this routine as the largest single buffer size.  We
+ * also check that this data will actually be used before going to the
+ * trouble of calculating it.
+ */
+void /* PRIVATE */
+png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
+{
+   int need_crc = 1;
+
+   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
+   {
+      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
+          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
+         need_crc = 0;
+   }
+   else                                                    /* critical */
+   {
+      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
+         need_crc = 0;
+   }
+
+   if (need_crc)
+      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
+}
+
+/* Allocate the memory for an info_struct for the application.  We don't
+ * really need the png_ptr, but it could potentially be useful in the
+ * future.  This should be used in favour of malloc(png_sizeof(png_info))
+ * and png_info_init() so that applications that want to use a shared
+ * libpng don't have to be recompiled if png_info changes size.
+ */
+png_infop PNGAPI
+png_create_info_struct(png_structp png_ptr)
+{
+   png_infop info_ptr;
+
+   png_debug(1, "in png_create_info_struct");
+
+   if (png_ptr == NULL)
+      return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
+      png_ptr->malloc_fn, png_ptr->mem_ptr);
+#else
+   info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
+#endif
+   if (info_ptr != NULL)
+      png_info_init_3(&info_ptr, png_sizeof(png_info));
+
+   return (info_ptr);
+}
+
+/* This function frees the memory associated with a single info struct.
+ * Normally, one would use either png_destroy_read_struct() or
+ * png_destroy_write_struct() to free an info struct, but this may be
+ * useful for some applications.
+ */
+void PNGAPI
+png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
+{
+   png_infop info_ptr = NULL;
+
+   png_debug(1, "in png_destroy_info_struct");
+
+   if (png_ptr == NULL)
+      return;
+
+   if (info_ptr_ptr != NULL)
+      info_ptr = *info_ptr_ptr;
+
+   if (info_ptr != NULL)
+   {
+      png_info_destroy(png_ptr, info_ptr);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
+          png_ptr->mem_ptr);
+#else
+      png_destroy_struct((png_voidp)info_ptr);
+#endif
+      *info_ptr_ptr = NULL;
+   }
+}
+
+/* Initialize the info structure.  This is now an internal function (0.89)
+ * and applications using it are urged to use png_create_info_struct()
+ * instead.
+ */
+
+void PNGAPI
+png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
+{
+   png_infop info_ptr = *ptr_ptr;
+
+   png_debug(1, "in png_info_init_3");
+
+   if (info_ptr == NULL)
+      return;
+
+   if (png_sizeof(png_info) > png_info_struct_size)
+   {
+      png_destroy_struct(info_ptr);
+      info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
+      *ptr_ptr = info_ptr;
+   }
+
+   /* Set everything to 0 */
+   png_memset(info_ptr, 0, png_sizeof(png_info));
+}
+
+void PNGAPI
+png_data_freer(png_structp png_ptr, png_infop info_ptr,
+   int freer, png_uint_32 mask)
+{
+   png_debug(1, "in png_data_freer");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   if (freer == PNG_DESTROY_WILL_FREE_DATA)
+      info_ptr->free_me |= mask;
+   else if (freer == PNG_USER_WILL_FREE_DATA)
+      info_ptr->free_me &= ~mask;
+   else
+      png_warning(png_ptr,
+         "Unknown freer parameter in png_data_freer");
+}
+
+void PNGAPI
+png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
+   int num)
+{
+   png_debug(1, "in png_free_data");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+#ifdef PNG_TEXT_SUPPORTED
+   /* Free text item num or (if num == -1) all text items */
+   if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
+   {
+      if (num != -1)
+      {
+         if (info_ptr->text && info_ptr->text[num].key)
+         {
+            png_free(png_ptr, info_ptr->text[num].key);
+            info_ptr->text[num].key = NULL;
+         }
+      }
+      else
+      {
+         int i;
+         for (i = 0; i < info_ptr->num_text; i++)
+             png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
+         png_free(png_ptr, info_ptr->text);
+         info_ptr->text = NULL;
+         info_ptr->num_text=0;
+      }
+   }
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+   /* Free any tRNS entry */
+   if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
+   {
+      png_free(png_ptr, info_ptr->trans_alpha);
+      info_ptr->trans_alpha = NULL;
+      info_ptr->valid &= ~PNG_INFO_tRNS;
+   }
+#endif
+
+#ifdef PNG_sCAL_SUPPORTED
+   /* Free any sCAL entry */
+   if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
+   {
+#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_height);
+      info_ptr->scal_s_width = NULL;
+      info_ptr->scal_s_height = NULL;
+#endif
+      info_ptr->valid &= ~PNG_INFO_sCAL;
+   }
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+   /* Free any pCAL entry */
+   if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
+   {
+      png_free(png_ptr, info_ptr->pcal_purpose);
+      png_free(png_ptr, info_ptr->pcal_units);
+      info_ptr->pcal_purpose = NULL;
+      info_ptr->pcal_units = NULL;
+      if (info_ptr->pcal_params != NULL)
+         {
+            int i;
+            for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
+            {
+               png_free(png_ptr, info_ptr->pcal_params[i]);
+               info_ptr->pcal_params[i] = NULL;
+            }
+            png_free(png_ptr, info_ptr->pcal_params);
+            info_ptr->pcal_params = NULL;
+         }
+      info_ptr->valid &= ~PNG_INFO_pCAL;
+   }
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+   /* Free any iCCP entry */
+   if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
+   {
+      png_free(png_ptr, info_ptr->iccp_name);
+      png_free(png_ptr, info_ptr->iccp_profile);
+      info_ptr->iccp_name = NULL;
+      info_ptr->iccp_profile = NULL;
+      info_ptr->valid &= ~PNG_INFO_iCCP;
+   }
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+   /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
+   if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
+   {
+      if (num != -1)
+      {
+         if (info_ptr->splt_palettes)
+         {
+            png_free(png_ptr, info_ptr->splt_palettes[num].name);
+            png_free(png_ptr, info_ptr->splt_palettes[num].entries);
+            info_ptr->splt_palettes[num].name = NULL;
+            info_ptr->splt_palettes[num].entries = NULL;
+         }
+      }
+      else
+      {
+         if (info_ptr->splt_palettes_num)
+         {
+            int i;
+            for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
+               png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
+
+            png_free(png_ptr, info_ptr->splt_palettes);
+            info_ptr->splt_palettes = NULL;
+            info_ptr->splt_palettes_num = 0;
+         }
+         info_ptr->valid &= ~PNG_INFO_sPLT;
+      }
+   }
+#endif
+
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+   if (png_ptr->unknown_chunk.data)
+   {
+      png_free(png_ptr, png_ptr->unknown_chunk.data);
+      png_ptr->unknown_chunk.data = NULL;
+   }
+
+   if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
+   {
+      if (num != -1)
+      {
+          if (info_ptr->unknown_chunks)
+          {
+             png_free(png_ptr, info_ptr->unknown_chunks[num].data);
+             info_ptr->unknown_chunks[num].data = NULL;
+          }
+      }
+      else
+      {
+         int i;
+
+         if (info_ptr->unknown_chunks_num)
+         {
+            for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
+               png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
+
+            png_free(png_ptr, info_ptr->unknown_chunks);
+            info_ptr->unknown_chunks = NULL;
+            info_ptr->unknown_chunks_num = 0;
+         }
+      }
+   }
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+   /* Free any hIST entry */
+   if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
+   {
+      png_free(png_ptr, info_ptr->hist);
+      info_ptr->hist = NULL;
+      info_ptr->valid &= ~PNG_INFO_hIST;
+   }
+#endif
+
+   /* Free any PLTE entry that was internally allocated */
+   if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
+   {
+      png_zfree(png_ptr, info_ptr->palette);
+      info_ptr->palette = NULL;
+      info_ptr->valid &= ~PNG_INFO_PLTE;
+      info_ptr->num_palette = 0;
+   }
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+   /* Free any image bits attached to the info structure */
+   if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
+   {
+      if (info_ptr->row_pointers)
+      {
+         int row;
+         for (row = 0; row < (int)info_ptr->height; row++)
+         {
+            png_free(png_ptr, info_ptr->row_pointers[row]);
+            info_ptr->row_pointers[row] = NULL;
+         }
+         png_free(png_ptr, info_ptr->row_pointers);
+         info_ptr->row_pointers = NULL;
+      }
+      info_ptr->valid &= ~PNG_INFO_IDAT;
+   }
+#endif
+
+   if (num == -1)
+      info_ptr->free_me &= ~mask;
+   else
+      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
+}
+
+/* This is an internal routine to free any memory that the info struct is
+ * pointing to before re-using it or freeing the struct itself.  Recall
+ * that png_free() checks for NULL pointers for us.
+ */
+void /* PRIVATE */
+png_info_destroy(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_info_destroy");
+
+   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+   if (png_ptr->num_chunk_list)
+   {
+      png_free(png_ptr, png_ptr->chunk_list);
+      png_ptr->chunk_list = NULL;
+      png_ptr->num_chunk_list = 0;
+   }
+#endif
+
+   png_info_init_3(&info_ptr, png_sizeof(png_info));
+}
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
+
+/* This function returns a pointer to the io_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy() or png_read_destroy() are called.
+ */
+png_voidp PNGAPI
+png_get_io_ptr(png_structp png_ptr)
+{
+   if (png_ptr == NULL)
+      return (NULL);
+   return (png_ptr->io_ptr);
+}
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#ifdef PNG_STDIO_SUPPORTED
+/* Initialize the default input/output functions for the PNG file.  If you
+ * use your own read or write routines, you can call either png_set_read_fn()
+ * or png_set_write_fn() instead of png_init_io().  If you have defined
+ * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
+ * necessarily available.
+ */
+void PNGAPI
+png_init_io(png_structp png_ptr, png_FILE_p fp)
+{
+   png_debug(1, "in png_init_io");
+
+   if (png_ptr == NULL)
+      return;
+
+   png_ptr->io_ptr = (png_voidp)fp;
+}
+#endif
+
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+/* Convert the supplied time into an RFC 1123 string suitable for use in
+ * a "Creation Time" or other text-based time string.
+ */
+png_charp PNGAPI
+png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
+{
+   static PNG_CONST char short_months[12][4] =
+        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+   if (png_ptr == NULL)
+      return (NULL);
+   if (png_ptr->time_buffer == NULL)
+   {
+      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
+         png_sizeof(char)));
+   }
+
+#ifdef USE_FAR_KEYWORD
+   {
+      char near_time_buf[29];
+      png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",
+          ptime->day % 32, short_months[(ptime->month - 1) % 12],
+          ptime->year, ptime->hour % 24, ptime->minute % 60,
+          ptime->second % 61);
+      png_memcpy(png_ptr->time_buffer, near_time_buf,
+          29*png_sizeof(char));
+   }
+#else
+   png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",
+       ptime->day % 32, short_months[(ptime->month - 1) % 12],
+       ptime->year, ptime->hour % 24, ptime->minute % 60,
+       ptime->second % 61);
+#endif
+   return ((png_charp)png_ptr->time_buffer);
+}
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
+
+png_charp PNGAPI
+png_get_copyright(png_structp png_ptr)
+{
+   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */
+#ifdef PNG_STRING_COPYRIGHT
+      return PNG_STRING_COPYRIGHT
+#else
+#ifdef __STDC__
+   return ((png_charp) PNG_STRING_NEWLINE \
+     "libpng version 1.4.0 - January 3, 2010" PNG_STRING_NEWLINE \
+     "Copyright (c) 1998-2010 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
+     "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
+     "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
+     PNG_STRING_NEWLINE);
+#else
+      return ((png_charp) "libpng version 1.4.0 - January 3, 2010\
+      Copyright (c) 1998-2010 Glenn Randers-Pehrson\
+      Copyright (c) 1996-1997 Andreas Dilger\
+      Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.");
+#endif
+#endif
+}
+
+/* The following return the library version as a short string in the
+ * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
+ * used with your application, print out PNG_LIBPNG_VER_STRING, which
+ * is defined in png.h.
+ * Note: now there is no difference between png_get_libpng_ver() and
+ * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
+ * it is guaranteed that png.c uses the correct version of png.h.
+ */
+png_charp PNGAPI
+png_get_libpng_ver(png_structp png_ptr)
+{
+   /* Version of *.c files used when building libpng */
+   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */
+   return ((png_charp) PNG_LIBPNG_VER_STRING);
+}
+
+png_charp PNGAPI
+png_get_header_ver(png_structp png_ptr)
+{
+   /* Version of *.h files used when building libpng */
+   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */
+   return ((png_charp) PNG_LIBPNG_VER_STRING);
+}
+
+png_charp PNGAPI
+png_get_header_version(png_structp png_ptr)
+{
+   /* Returns longer string containing both version and date */
+   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */
+#ifdef __STDC__
+   return ((png_charp) PNG_HEADER_VERSION_STRING
+#ifndef PNG_READ_SUPPORTED
+   "     (NO READ SUPPORT)"
+#endif
+   PNG_STRING_NEWLINE);
+#else
+   return ((png_charp) PNG_HEADER_VERSION_STRING);
+#endif
+}
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+int PNGAPI
+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 */
+   int i;
+   png_bytep p;
+   if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
+      return 0;
+   p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;
+   for (i = png_ptr->num_chunk_list; i; i--, p -= 5)
+      if (!png_memcmp(chunk_name, p, 4))
+        return ((int)*(p + 4));
+   return 0;
+}
+#endif
+
+/* This function, added to libpng-1.0.6g, is untested. */
+int PNGAPI
+png_reset_zstream(png_structp png_ptr)
+{
+   if (png_ptr == NULL)
+      return Z_STREAM_ERROR;
+   return (inflateReset(&png_ptr->zstream));
+}
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
+
+/* This function was added to libpng-1.0.7 */
+png_uint_32 PNGAPI
+png_access_version_number(void)
+{
+   /* Version of *.c files used when building libpng */
+   return((png_uint_32) PNG_LIBPNG_VER);
+}
+
+
+
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#ifdef PNG_SIZE_T
+/* Added at libpng version 1.2.6 */
+   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
+png_size_t PNGAPI
+png_convert_size(size_t size)
+{
+   if (size > (png_size_t)-1)
+      PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
+   return ((png_size_t)size);
+}
+#endif /* PNG_SIZE_T */
+
+/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
+#ifdef PNG_cHRM_SUPPORTED
+#ifdef PNG_CHECK_cHRM_SUPPORTED
+
+/*
+ *    Multiply two 32-bit numbers, V1 and V2, using 32-bit
+ *    arithmetic, to produce a 64 bit result in the HI/LO words.
+ *
+ *                  A B
+ *                x C D
+ *               ------
+ *              AD || BD
+ *        AC || CB || 0
+ *
+ *    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
+ *    A and D, and X || Y is (X << 16) + Y.
+*/
+
+void /* PRIVATE */
+png_64bit_product (long v1, long v2, unsigned long *hi_product,
+   unsigned long *lo_product)
+{
+   int a, b, c, d;
+   long lo, hi, x, y;
+
+   a = (v1 >> 16) & 0xffff;
+   b = v1 & 0xffff;
+   c = (v2 >> 16) & 0xffff;
+   d = v2 & 0xffff;
+
+   lo = b * d;                   /* BD */
+   x = a * d + c * b;            /* AD + CB */
+   y = ((lo >> 16) & 0xffff) + x;
+
+   lo = (lo & 0xffff) | ((y & 0xffff) << 16);
+   hi = (y >> 16) & 0xffff;
+
+   hi += a * c;                  /* AC */
+
+   *hi_product = (unsigned long)hi;
+   *lo_product = (unsigned long)lo;
+}
+
+int /* PRIVATE */
+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 red_y, png_fixed_point green_x, png_fixed_point green_y,
+   png_fixed_point blue_x, png_fixed_point blue_y)
+{
+   int ret = 1;
+   unsigned long xy_hi,xy_lo,yx_hi,yx_lo;
+
+   png_debug(1, "in function png_check_cHRM_fixed");
+
+   if (png_ptr == NULL)
+      return 0;
+
+   if (white_x < 0 || white_y <= 0 ||
+         red_x < 0 ||   red_y <  0 ||
+       green_x < 0 || green_y <  0 ||
+        blue_x < 0 ||  blue_y <  0)
+   {
+      png_warning(png_ptr,
+        "Ignoring attempt to set negative chromaticity value");
+      ret = 0;
+   }
+   if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||
+       white_y > (png_fixed_point) PNG_UINT_31_MAX ||
+         red_x > (png_fixed_point) PNG_UINT_31_MAX ||
+         red_y > (png_fixed_point) PNG_UINT_31_MAX ||
+       green_x > (png_fixed_point) PNG_UINT_31_MAX ||
+       green_y > (png_fixed_point) PNG_UINT_31_MAX ||
+        blue_x > (png_fixed_point) PNG_UINT_31_MAX ||
+        blue_y > (png_fixed_point) PNG_UINT_31_MAX )
+   {
+      png_warning(png_ptr,
+        "Ignoring attempt to set chromaticity value exceeding 21474.83");
+      ret = 0;
+   }
+   if (white_x > 100000L - white_y)
+   {
+      png_warning(png_ptr, "Invalid cHRM white point");
+      ret = 0;
+   }
+   if (red_x > 100000L - red_y)
+   {
+      png_warning(png_ptr, "Invalid cHRM red point");
+      ret = 0;
+   }
+   if (green_x > 100000L - green_y)
+   {
+      png_warning(png_ptr, "Invalid cHRM green point");
+      ret = 0;
+   }
+   if (blue_x > 100000L - blue_y)
+   {
+      png_warning(png_ptr, "Invalid cHRM blue point");
+      ret = 0;
+   }
+
+   png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);
+   png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);
+
+   if (xy_hi == yx_hi && xy_lo == yx_lo)
+   {
+      png_warning(png_ptr,
+         "Ignoring attempt to set cHRM RGB triangle with zero area");
+      ret = 0;
+   }
+
+   return ret;
+}
+#endif /* PNG_CHECK_cHRM_SUPPORTED */
+#endif /* PNG_cHRM_SUPPORTED */
+
+void /* PRIVATE */
+png_check_IHDR(png_structp png_ptr,
+   png_uint_32 width, png_uint_32 height, int bit_depth,
+   int color_type, int interlace_type, int compression_type,
+   int filter_type)
+{
+   int error = 0;
+
+   /* Check for width and height valid values */
+   if (width == 0)
+   {
+      png_warning(png_ptr, "Image width is zero in IHDR");
+      error = 1;
+   }
+
+   if (height == 0)
+   {
+      png_warning(png_ptr, "Image height is zero in IHDR");
+      error = 1;
+   }
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX)
+#else
+   if (width > PNG_USER_WIDTH_MAX)
+#endif
+   {
+      png_warning(png_ptr, "Image width exceeds user limit in IHDR");
+      error = 1;
+   }
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX)
+#else
+   if (height > PNG_USER_HEIGHT_MAX)
+#endif
+   {
+      png_warning(png_ptr, "Image height exceeds user limit in IHDR");
+      error = 1;
+   }
+
+   if (width > PNG_UINT_31_MAX)
+   {
+      png_warning(png_ptr, "Invalid image width in IHDR");
+      error = 1;
+   }
+
+   if ( height > PNG_UINT_31_MAX)
+   {
+      png_warning(png_ptr, "Invalid image height in IHDR");
+      error = 1;
+   }
+
+   if ( width > (PNG_UINT_32_MAX
+                 >> 3)      /* 8-byte RGBA pixels */
+                 - 64       /* bigrowbuf hack */
+                 - 1        /* filter byte */
+                 - 7*8      /* rounding of width to multiple of 8 pixels */
+                 - 8)       /* extra max_pixel_depth pad */
+      png_warning(png_ptr, "Width is too large for libpng to process pixels");
+
+   /* Check other values */
+   if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
+       bit_depth != 8 && bit_depth != 16)
+   {
+      png_warning(png_ptr, "Invalid bit depth in IHDR");
+      error = 1;
+   }
+
+   if (color_type < 0 || color_type == 1 ||
+       color_type == 5 || color_type > 6)
+   {
+      png_warning(png_ptr, "Invalid color type in IHDR");
+      error = 1;
+   }
+
+   if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
+       ((color_type == PNG_COLOR_TYPE_RGB ||
+         color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
+         color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
+   {
+      png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
+      error = 1;
+   }
+
+   if (interlace_type >= PNG_INTERLACE_LAST)
+   {
+      png_warning(png_ptr, "Unknown interlace method in IHDR");
+      error = 1;
+   }
+
+   if (compression_type != PNG_COMPRESSION_TYPE_BASE)
+   {
+      png_warning(png_ptr, "Unknown compression method in IHDR");
+      error = 1;
+   }
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   /* Accept filter_method 64 (intrapixel differencing) only if
+    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
+    * 2. Libpng did not read a PNG signature (this filter_method is only
+    *    used in PNG datastreams that are embedded in MNG datastreams) and
+    * 3. The application called png_permit_mng_features with a mask that
+    *    included PNG_FLAG_MNG_FILTER_64 and
+    * 4. The filter_method is 64 and
+    * 5. The color_type is RGB or RGBA
+    */
+   if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&
+       png_ptr->mng_features_permitted)
+      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
+
+   if (filter_type != PNG_FILTER_TYPE_BASE)
+   {
+      if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+         (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
+         ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
+         (color_type == PNG_COLOR_TYPE_RGB ||
+         color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
+      {
+         png_warning(png_ptr, "Unknown filter method in IHDR");
+         error = 1;
+      }
+
+      if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
+      {
+         png_warning(png_ptr, "Invalid filter method in IHDR");
+         error = 1;
+      }
+   }
+
+#else
+   if (filter_type != PNG_FILTER_TYPE_BASE)
+   {
+      png_warning(png_ptr, "Unknown filter method in IHDR");
+      error = 1;
+   }
+#endif
+
+   if (error == 1)
+      png_error(png_ptr, "Invalid IHDR data");
+}
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
diff --git a/src/libpng/png.h b/src/libpng/png.h
index 4b3841216..14e34165c 100644
--- a/src/libpng/png.h
+++ b/src/libpng/png.h
@@ -1,3767 +1,2552 @@
-/* png.h - header file for PNG reference library

- *

- * libpng version 1.2.41 - December 3, 2009

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license (See LICENSE, below)

- *

- * Authors and maintainers:

- *  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.97, January 1998, through 1.2.41 - December 3, 2009: Glenn

- *  See also "Contributing Authors", below.

- *

- * Note about libpng version numbers:

- *

- *    Due to various miscommunications, unforeseen code incompatibilities

- *    and occasional factors outside the authors' control, version numbering

- *    on the library has not always been consistent and straightforward.

- *    The following table summarizes matters since version 0.89c, which was

- *    the first widely used release:

- *

- *    source                 png.h  png.h  shared-lib

- *    version                string   int  version

- *    -------                ------ -----  ----------

- *    0.89c "1.0 beta 3"     0.89      89  1.0.89

- *    0.90  "1.0 beta 4"     0.90      90  0.90  [should have been 2.0.90]

- *    0.95  "1.0 beta 5"     0.95      95  0.95  [should have been 2.0.95]

- *    0.96  "1.0 beta 6"     0.96      96  0.96  [should have been 2.0.96]

- *    0.97b "1.00.97 beta 7" 1.00.97   97  1.0.1 [should have been 2.0.97]

- *    0.97c                  0.97      97  2.0.97

- *    0.98                   0.98      98  2.0.98

- *    0.99                   0.99      98  2.0.99

- *    0.99a-m                0.99      99  2.0.99

- *    1.00                   1.00     100  2.1.0 [100 should be 10000]

- *    1.0.0      (from here on, the   100  2.1.0 [100 should be 10000]

- *    1.0.1       png.h string is   10001  2.1.0

- *    1.0.1a-e    identical to the  10002  from here on, the shared library

- *    1.0.2       source version)   10002  is 2.V where V is the source code

- *    1.0.2a-b                      10003  version, except as noted.

- *    1.0.3                         10003

- *    1.0.3a-d                      10004

- *    1.0.4                         10004

- *    1.0.4a-f                      10005

- *    1.0.5 (+ 2 patches)           10005

- *    1.0.5a-d                      10006

- *    1.0.5e-r                      10100 (not source compatible)

- *    1.0.5s-v                      10006 (not binary compatible)

- *    1.0.6 (+ 3 patches)           10006 (still binary incompatible)

- *    1.0.6d-f                      10007 (still binary incompatible)

- *    1.0.6g                        10007

- *    1.0.6h                        10007  10.6h (testing xy.z so-numbering)

- *    1.0.6i                        10007  10.6i

- *    1.0.6j                        10007  2.1.0.6j (incompatible with 1.0.0)

- *    1.0.7beta11-14        DLLNUM  10007  2.1.0.7beta11-14 (binary compatible)

- *    1.0.7beta15-18           1    10007  2.1.0.7beta15-18 (binary compatible)

- *    1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)

- *    1.0.7                    1    10007  (still compatible)

- *    1.0.8beta1-4             1    10008  2.1.0.8beta1-4

- *    1.0.8rc1                 1    10008  2.1.0.8rc1

- *    1.0.8                    1    10008  2.1.0.8

- *    1.0.9beta1-6             1    10009  2.1.0.9beta1-6

- *    1.0.9rc1                 1    10009  2.1.0.9rc1

- *    1.0.9beta7-10            1    10009  2.1.0.9beta7-10

- *    1.0.9rc2                 1    10009  2.1.0.9rc2

- *    1.0.9                    1    10009  2.1.0.9

- *    1.0.10beta1              1    10010  2.1.0.10beta1

- *    1.0.10rc1                1    10010  2.1.0.10rc1

- *    1.0.10                   1    10010  2.1.0.10

- *    1.0.11beta1-3            1    10011  2.1.0.11beta1-3

- *    1.0.11rc1                1    10011  2.1.0.11rc1

- *    1.0.11                   1    10011  2.1.0.11

- *    1.0.12beta1-2            2    10012  2.1.0.12beta1-2

- *    1.0.12rc1                2    10012  2.1.0.12rc1

- *    1.0.12                   2    10012  2.1.0.12

- *    1.1.0a-f                 -    10100  2.1.1.0a-f (branch abandoned)

- *    1.2.0beta1-2             2    10200  2.1.2.0beta1-2

- *    1.2.0beta3-5             3    10200  3.1.2.0beta3-5

- *    1.2.0rc1                 3    10200  3.1.2.0rc1

- *    1.2.0                    3    10200  3.1.2.0

- *    1.2.1beta1-4             3    10201  3.1.2.1beta1-4

- *    1.2.1rc1-2               3    10201  3.1.2.1rc1-2

- *    1.2.1                    3    10201  3.1.2.1

- *    1.2.2beta1-6            12    10202  12.so.0.1.2.2beta1-6

- *    1.0.13beta1             10    10013  10.so.0.1.0.13beta1

- *    1.0.13rc1               10    10013  10.so.0.1.0.13rc1

- *    1.2.2rc1                12    10202  12.so.0.1.2.2rc1

- *    1.0.13                  10    10013  10.so.0.1.0.13

- *    1.2.2                   12    10202  12.so.0.1.2.2

- *    1.2.3rc1-6              12    10203  12.so.0.1.2.3rc1-6

- *    1.2.3                   12    10203  12.so.0.1.2.3

- *    1.2.4beta1-3            13    10204  12.so.0.1.2.4beta1-3

- *    1.0.14rc1               13    10014  10.so.0.1.0.14rc1

- *    1.2.4rc1                13    10204  12.so.0.1.2.4rc1

- *    1.0.14                  10    10014  10.so.0.1.0.14

- *    1.2.4                   13    10204  12.so.0.1.2.4

- *    1.2.5beta1-2            13    10205  12.so.0.1.2.5beta1-2

- *    1.0.15rc1-3             10    10015  10.so.0.1.0.15rc1-3

- *    1.2.5rc1-3              13    10205  12.so.0.1.2.5rc1-3

- *    1.0.15                  10    10015  10.so.0.1.0.15

- *    1.2.5                   13    10205  12.so.0.1.2.5

- *    1.2.6beta1-4            13    10206  12.so.0.1.2.6beta1-4

- *    1.0.16                  10    10016  10.so.0.1.0.16

- *    1.2.6                   13    10206  12.so.0.1.2.6

- *    1.2.7beta1-2            13    10207  12.so.0.1.2.7beta1-2

- *    1.0.17rc1               10    10017  10.so.0.1.0.17rc1

- *    1.2.7rc1                13    10207  12.so.0.1.2.7rc1

- *    1.0.17                  10    10017  10.so.0.1.0.17

- *    1.2.7                   13    10207  12.so.0.1.2.7

- *    1.2.8beta1-5            13    10208  12.so.0.1.2.8beta1-5

- *    1.0.18rc1-5             10    10018  10.so.0.1.0.18rc1-5

- *    1.2.8rc1-5              13    10208  12.so.0.1.2.8rc1-5

- *    1.0.18                  10    10018  10.so.0.1.0.18

- *    1.2.8                   13    10208  12.so.0.1.2.8

- *    1.2.9beta1-3            13    10209  12.so.0.1.2.9beta1-3

- *    1.2.9beta4-11           13    10209  12.so.0.9[.0]

- *    1.2.9rc1                13    10209  12.so.0.9[.0]

- *    1.2.9                   13    10209  12.so.0.9[.0]

- *    1.2.10beta1-8           13    10210  12.so.0.10[.0]

- *    1.2.10rc1-3             13    10210  12.so.0.10[.0]

- *    1.2.10                  13    10210  12.so.0.10[.0]

- *    1.2.11beta1-4           13    10211  12.so.0.11[.0]

- *    1.0.19rc1-5             10    10019  10.so.0.19[.0]

- *    1.2.11rc1-5             13    10211  12.so.0.11[.0]

- *    1.0.19                  10    10019  10.so.0.19[.0]

- *    1.2.11                  13    10211  12.so.0.11[.0]

- *    1.0.20                  10    10020  10.so.0.20[.0]

- *    1.2.12                  13    10212  12.so.0.12[.0]

- *    1.2.13beta1             13    10213  12.so.0.13[.0]

- *    1.0.21                  10    10021  10.so.0.21[.0]

- *    1.2.13                  13    10213  12.so.0.13[.0]

- *    1.2.14beta1-2           13    10214  12.so.0.14[.0]

- *    1.0.22rc1               10    10022  10.so.0.22[.0]

- *    1.2.14rc1               13    10214  12.so.0.14[.0]

- *    1.0.22                  10    10022  10.so.0.22[.0]

- *    1.2.14                  13    10214  12.so.0.14[.0]

- *    1.2.15beta1-6           13    10215  12.so.0.15[.0]

- *    1.0.23rc1-5             10    10023  10.so.0.23[.0]

- *    1.2.15rc1-5             13    10215  12.so.0.15[.0]

- *    1.0.23                  10    10023  10.so.0.23[.0]

- *    1.2.15                  13    10215  12.so.0.15[.0]

- *    1.2.16beta1-2           13    10216  12.so.0.16[.0]

- *    1.2.16rc1               13    10216  12.so.0.16[.0]

- *    1.0.24                  10    10024  10.so.0.24[.0]

- *    1.2.16                  13    10216  12.so.0.16[.0]

- *    1.2.17beta1-2           13    10217  12.so.0.17[.0]

- *    1.0.25rc1               10    10025  10.so.0.25[.0]

- *    1.2.17rc1-3             13    10217  12.so.0.17[.0]

- *    1.0.25                  10    10025  10.so.0.25[.0]

- *    1.2.17                  13    10217  12.so.0.17[.0]

- *    1.0.26                  10    10026  10.so.0.26[.0]

- *    1.2.18                  13    10218  12.so.0.18[.0]

- *    1.2.19beta1-31          13    10219  12.so.0.19[.0]

- *    1.0.27rc1-6             10    10027  10.so.0.27[.0]

- *    1.2.19rc1-6             13    10219  12.so.0.19[.0]

- *    1.0.27                  10    10027  10.so.0.27[.0]

- *    1.2.19                  13    10219  12.so.0.19[.0]

- *    1.2.20beta01-04         13    10220  12.so.0.20[.0]

- *    1.0.28rc1-6             10    10028  10.so.0.28[.0]

- *    1.2.20rc1-6             13    10220  12.so.0.20[.0]

- *    1.0.28                  10    10028  10.so.0.28[.0]

- *    1.2.20                  13    10220  12.so.0.20[.0]

- *    1.2.21beta1-2           13    10221  12.so.0.21[.0]

- *    1.2.21rc1-3             13    10221  12.so.0.21[.0]

- *    1.0.29                  10    10029  10.so.0.29[.0]

- *    1.2.21                  13    10221  12.so.0.21[.0]

- *    1.2.22beta1-4           13    10222  12.so.0.22[.0]

- *    1.0.30rc1               10    10030  10.so.0.30[.0]

- *    1.2.22rc1               13    10222  12.so.0.22[.0]

- *    1.0.30                  10    10030  10.so.0.30[.0]

- *    1.2.22                  13    10222  12.so.0.22[.0]

- *    1.2.23beta01-05         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.24beta01-02         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.25beta01-06         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.2.25                  13    10225  12.so.0.25[.0]

- *    1.2.26beta01-06         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.0.32                  10    10032  10.so.0.32[.0]

- *    1.2.27beta01-06         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.2.27                  13    10227  12.so.0.27[.0]

- *    1.0.34                  10    10034  10.so.0.34[.0]

- *    1.2.28                  13    10228  12.so.0.28[.0]

- *    1.2.29beta01-03         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.2.29                  13    10229  12.so.0.29[.0]

- *    1.0.37                  10    10037  10.so.0.37[.0]

- *    1.2.30beta01-04         13    10230  12.so.0.30[.0]

- *    1.0.38rc01-08           10    10038  10.so.0.38[.0]

- *    1.2.30rc01-08           13    10230  12.so.0.30[.0]

- *    1.0.38                  10    10038  10.so.0.38[.0]

- *    1.2.30                  13    10230  12.so.0.30[.0]

- *    1.0.39rc01-03           10    10039  10.so.0.39[.0]

- *    1.2.31rc01-03           13    10231  12.so.0.31[.0]

- *    1.0.39                  10    10039  10.so.0.39[.0]

- *    1.2.31                  13    10231  12.so.0.31[.0]

- *    1.2.32beta01-02         13    10232  12.so.0.32[.0]

- *    1.0.40rc01              10    10040  10.so.0.40[.0]

- *    1.2.32rc01              13    10232  12.so.0.32[.0]

- *    1.0.40                  10    10040  10.so.0.40[.0]

- *    1.2.32                  13    10232  12.so.0.32[.0]

- *    1.2.33beta01-02         13    10233  12.so.0.33[.0]

- *    1.2.33rc01-02           13    10233  12.so.0.33[.0]

- *    1.0.41rc01              10    10041  10.so.0.41[.0]

- *    1.2.33                  13    10233  12.so.0.33[.0]

- *    1.0.41                  10    10041  10.so.0.41[.0]

- *    1.2.34beta01-07         13    10234  12.so.0.34[.0]

- *    1.0.42rc01              10    10042  10.so.0.42[.0]

- *    1.2.34rc01              13    10234  12.so.0.34[.0]

- *    1.0.42                  10    10042  10.so.0.42[.0]

- *    1.2.34                  13    10234  12.so.0.34[.0]

- *    1.2.35beta01-03         13    10235  12.so.0.35[.0]

- *    1.0.43rc01-02           10    10043  10.so.0.43[.0]

- *    1.2.35rc01-02           13    10235  12.so.0.35[.0]

- *    1.0.43                  10    10043  10.so.0.43[.0]

- *    1.2.35                  13    10235  12.so.0.35[.0]

- *    1.2.36beta01-05         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.2.36                  13    10236  12.so.0.36[.0]

- *    1.2.37beta01-03         13    10237  12.so.0.37[.0]

- *    1.2.37rc01              13    10237  12.so.0.37[.0]

- *    1.2.37                  13    10237  12.so.0.37[.0]

- *    1.2.45                  10    10045  12.so.0.45[.0]

- *    1.0.46                  10    10046  10.so.0.46[.0]

- *    1.2.38beta01            13    10238  12.so.0.38[.0]

- *    1.2.38rc01-03           13    10238  12.so.0.38[.0]

- *    1.0.47                  10    10047  10.so.0.47[.0]

- *    1.2.38                  13    10238  12.so.0.38[.0]

- *    1.2.39beta01-05         13    10239  12.so.0.39[.0]

- *    1.2.39rc01              13    10239  12.so.0.39[.0]

- *    1.0.48                  10    10048  10.so.0.48[.0]

- *    1.2.39                  13    10239  12.so.0.39[.0]

- *    1.2.40beta01            13    10240  12.so.0.40[.0]

- *    1.2.40rc01              13    10240  12.so.0.40[.0]

- *    1.0.49                  10    10049  10.so.0.49[.0]

- *    1.2.40                  13    10240  12.so.0.40[.0]

- *    1.2.41beta01-18         13    10241  12.so.0.41[.0]

- *    1.0.51rc01              10    10051  10.so.0.51[.0]

- *    1.2.41rc01-03           13    10241  12.so.0.41[.0]

- *    1.0.51                  10    10051  10.so.0.51[.0]

- *    1.2.41                  13    10241  12.so.0.41[.0]

- *

- *    Henceforth the source version will match the shared-library major

- *    and minor numbers; the shared-library major version number will be

- *    used for changes in backward compatibility, as it is intended.  The

- *    PNG_LIBPNG_VER macro, which is not used within libpng but is available

- *    for applications, is an unsigned integer of the form xyyzz corresponding

- *    to the source version x.y.z (leading zeros in y and z).  Beta versions

- *    were given the previous public release number plus a letter, until

- *    version 1.0.6j; from then on they were given the upcoming public

- *    release number plus "betaNN" or "rcNN".

- *

- *    Binary incompatibility exists only when applications make direct access

- *    to the info_ptr or png_ptr members through png.h, and the compiled

- *    application is loaded with a different version of the library.

- *

- *    DLLNUM will change each time there are forward or backward changes

- *    in binary compatibility (e.g., when a new feature is added).

- *

- * See libpng.txt or libpng.3 for more information.  The PNG specification

- * is available as a W3C Recommendation and as an ISO Specification,

- * <http://www.w3.org/TR/2003/REC-PNG-20031110/

- */

-

-/*

- * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

- *

- * If you modify libpng you may insert additional notices immediately following

- * this sentence.

- *

- * This code is released under the libpng license.

- *

- * libpng versions 1.2.6, August 15, 2004, through 1.2.41, December 3, 2009, are

- * Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are

- * distributed according to the same disclaimer and license as libpng-1.2.5

- * with the following individual added to the list of Contributing Authors:

- *

- *    Cosmin Truta

- *

- * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are

- * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are

- * distributed according to the same disclaimer and license as libpng-1.0.6

- * with the following individuals added to the list of Contributing Authors:

- *

- *    Simon-Pierre Cadieux

- *    Eric S. Raymond

- *    Gilles Vollant

- *

- * and with the following additions to the disclaimer:

- *

- *    There is no warranty against interference with your enjoyment of the

- *    library or against infringement.  There is no warranty that our

- *    efforts or the library will fulfill any of your particular purposes

- *    or needs.  This library is provided with all faults, and the entire

- *    risk of satisfactory quality, performance, accuracy, and effort is with

- *    the user.

- *

- * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are

- * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are

- * distributed according to the same disclaimer and license as libpng-0.96,

- * with the following individuals added to the list of Contributing Authors:

- *

- *    Tom Lane

- *    Glenn Randers-Pehrson

- *    Willem van Schaik

- *

- * libpng versions 0.89, June 1996, through 0.96, May 1997, are

- * Copyright (c) 1996, 1997 Andreas Dilger

- * Distributed according to the same disclaimer and license as libpng-0.88,

- * with the following individuals added to the list of Contributing Authors:

- *

- *    John Bowler

- *    Kevin Bracey

- *    Sam Bushell

- *    Magnus Holmgren

- *    Greg Roelofs

- *    Tom Tanner

- *

- * libpng versions 0.5, May 1995, through 0.88, January 1996, are

- * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.

- *

- * For the purposes of this copyright and license, "Contributing Authors"

- * is defined as the following set of individuals:

- *

- *    Andreas Dilger

- *    Dave Martindale

- *    Guy Eric Schalnat

- *    Paul Schmidt

- *    Tim Wegner

- *

- * The PNG Reference Library is supplied "AS IS".  The Contributing Authors

- * and Group 42, Inc. disclaim all warranties, expressed or implied,

- * including, without limitation, the warranties of merchantability and of

- * fitness for any purpose.  The Contributing Authors and Group 42, Inc.

- * assume no liability for direct, indirect, incidental, special, exemplary,

- * or consequential damages, which may result from the use of the PNG

- * Reference Library, even if advised of the possibility of such damage.

- *

- * Permission is hereby granted to use, copy, modify, and distribute this

- * source code, or portions hereof, for any purpose, without fee, subject

- * to the following restrictions:

- *

- * 1. The origin of this source code must not be misrepresented.

- *

- * 2. Altered versions must be plainly marked as such and

- * must not be misrepresented as being the original source.

- *

- * 3. This Copyright notice may not be removed or altered from

- *    any source or altered source distribution.

- *

- * The Contributing Authors and Group 42, Inc. specifically permit, without

- * fee, and encourage the use of this source code as a component to

- * supporting the PNG file format in commercial products.  If you use this

- * source code in a product, acknowledgment is not required but would be

- * appreciated.

- */

-

-/*

- * A "png_get_copyright" function is available, for convenient use in "about"

- * boxes and the like:

- *

- * printf("%s",png_get_copyright(NULL));

- *

- * Also, the PNG logo (in PNG format, of course) is supplied in the

- * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).

- */

-

-/*

- * Libpng is OSI Certified Open Source Software.  OSI Certified is a

- * certification mark of the Open Source Initiative.

- */

-

-/*

- * The contributing authors would like to thank all those who helped

- * with testing, bug fixes, and patience.  This wouldn't have been

- * possible without all of you.

- *

- * Thanks to Frank J. T. Wojcik for helping with the documentation.

- */

-

-/*

- * Y2K compliance in libpng:

- * =========================

- *

- *    December 3, 2009

- *

- *    Since the PNG Development group is an ad-hoc body, we can't make

- *    an official declaration.

- *

- *    This is your unofficial assurance that libpng from version 0.71 and

- *    upward through 1.2.41 are Y2K compliant.  It is my belief that earlier

- *    versions were also Y2K compliant.

- *

- *    Libpng only has three year fields.  One is a 2-byte unsigned integer

- *    that will hold years up to 65535.  The other two hold the date in text

- *    format, and will hold years up to 9999.

- *

- *    The integer is

- *        "png_uint_16 year" in png_time_struct.

- *

- *    The strings are

- *        "png_charp time_buffer" in png_struct and

- *        "near_time_buffer", which is a local character string in png.c.

- *

- *    There are seven time-related functions:

- *        png.c: png_convert_to_rfc_1123() in png.c

- *          (formerly png_convert_to_rfc_1152() in error)

- *        png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c

- *        png_convert_from_time_t() in pngwrite.c

- *        png_get_tIME() in pngget.c

- *        png_handle_tIME() in pngrutil.c, called in pngread.c

- *        png_set_tIME() in pngset.c

- *        png_write_tIME() in pngwutil.c, called in pngwrite.c

- *

- *    All handle dates properly in a Y2K environment.  The

- *    png_convert_from_time_t() function calls gmtime() to convert from system

- *    clock time, which returns (year - 1900), which we properly convert to

- *    the full 4-digit year.  There is a possibility that applications using

- *    libpng are not passing 4-digit years into the png_convert_to_rfc_1123()

- *    function, or that they are incorrectly passing only a 2-digit year

- *    instead of "year - 1900" into the png_convert_from_struct_tm() function,

- *    but this is not under our control.  The libpng documentation has always

- *    stated that it works with 4-digit years, and the APIs have been

- *    documented as such.

- *

- *    The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned

- *    integer to hold the year, and can hold years as large as 65535.

- *

- *    zlib, upon which libpng depends, is also Y2K compliant.  It contains

- *    no date-related code.

- *

- *       Glenn Randers-Pehrson

- *       libpng maintainer

- *       PNG Development Group

- */

-

-#ifndef PNG_H

-#define PNG_H

-

-/* This is not the place to learn how to use libpng.  The file libpng.txt

- * describes how to use libpng, and the file example.c summarizes it

- * with some code on which to build.  This file is useful for looking

- * at the actual function definitions and structure components.

- */

-

-/* Version information for png.h - this should match the version in png.c */

-#define PNG_LIBPNG_VER_STRING "1.2.41"

-#define PNG_HEADER_VERSION_STRING \

-   " libpng version 1.2.41 - December 3, 2009\n"

-

-#define PNG_LIBPNG_VER_SONUM   0

-#define PNG_LIBPNG_VER_DLLNUM  13

-

-/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */

-#define PNG_LIBPNG_VER_MAJOR   1

-#define PNG_LIBPNG_VER_MINOR   2

-#define PNG_LIBPNG_VER_RELEASE 41

-/* This should match the numeric part of the final component of

- * PNG_LIBPNG_VER_STRING, omitting any leading zero:

- */

-

-#define PNG_LIBPNG_VER_BUILD  0

-

-/* Release Status */

-#define PNG_LIBPNG_BUILD_ALPHA    1

-#define PNG_LIBPNG_BUILD_BETA     2

-#define PNG_LIBPNG_BUILD_RC       3

-#define PNG_LIBPNG_BUILD_STABLE   4

-#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7

-

-/* Release-Specific Flags */

-#define PNG_LIBPNG_BUILD_PATCH    8 /* Can be OR'ed with

-                                       PNG_LIBPNG_BUILD_STABLE only */

-#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with

-                                       PNG_LIBPNG_BUILD_SPECIAL */

-#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with

-                                       PNG_LIBPNG_BUILD_PRIVATE */

-

-#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE

-

-/* Careful here.  At one time, Guy wanted to use 082, but that would be octal.

- * We must not include leading zeros.

- * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only

- * version 1.0.0 was mis-numbered 100 instead of 10000).  From

- * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release

- */

-#define PNG_LIBPNG_VER 10241 /* 1.2.41 */

-

-#ifndef PNG_VERSION_INFO_ONLY

-/* Include the compression library's header */

-#include "zlib.h"

-#endif

-

-/* Include all user configurable info, including optional assembler routines */

-#include "pngconf.h"

-

-/*

- * Added at libpng-1.2.8 */

-/* Ref MSDN: Private as priority over Special

- * VS_FF_PRIVATEBUILD File *was not* built using standard release

- * procedures. If this value is given, the StringFileInfo block must

- * contain a PrivateBuild string.

- *

- * VS_FF_SPECIALBUILD File *was* built by the original company using

- * standard release procedures but is a variation of the standard

- * file of the same version number. If this value is given, the

- * StringFileInfo block must contain a SpecialBuild string.

- */

-

-#ifdef PNG_USER_PRIVATEBUILD

-#  define PNG_LIBPNG_BUILD_TYPE \

-          (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)

-#else

-#  ifdef PNG_LIBPNG_SPECIALBUILD

-#    define PNG_LIBPNG_BUILD_TYPE \

-            (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)

-#  else

-#    define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)

-#  endif

-#endif

-

-#ifndef PNG_VERSION_INFO_ONLY

-

-/* Inhibit C++ name-mangling for libpng functions but not for system calls. */

-#ifdef __cplusplus

-extern "C" {

-#endif /* __cplusplus */

-

-/* This file is arranged in several sections.  The first section contains

- * structure and type definitions.  The second section contains the external

- * library functions, while the third has the internal library functions,

- * which applications aren't expected to use directly.

- */

-

-#ifndef PNG_NO_TYPECAST_NULL

-#define int_p_NULL                (int *)NULL

-#define png_bytep_NULL            (png_bytep)NULL

-#define png_bytepp_NULL           (png_bytepp)NULL

-#define png_doublep_NULL          (png_doublep)NULL

-#define png_error_ptr_NULL        (png_error_ptr)NULL

-#define png_flush_ptr_NULL        (png_flush_ptr)NULL

-#define png_free_ptr_NULL         (png_free_ptr)NULL

-#define png_infopp_NULL           (png_infopp)NULL

-#define png_malloc_ptr_NULL       (png_malloc_ptr)NULL

-#define png_read_status_ptr_NULL  (png_read_status_ptr)NULL

-#define png_rw_ptr_NULL           (png_rw_ptr)NULL

-#define png_structp_NULL          (png_structp)NULL

-#define png_uint_16p_NULL         (png_uint_16p)NULL

-#define png_voidp_NULL            (png_voidp)NULL

-#define png_write_status_ptr_NULL (png_write_status_ptr)NULL

-#else

-#define int_p_NULL                NULL

-#define png_bytep_NULL            NULL

-#define png_bytepp_NULL           NULL

-#define png_doublep_NULL          NULL

-#define png_error_ptr_NULL        NULL

-#define png_flush_ptr_NULL        NULL

-#define png_free_ptr_NULL         NULL

-#define png_infopp_NULL           NULL

-#define png_malloc_ptr_NULL       NULL

-#define png_read_status_ptr_NULL  NULL

-#define png_rw_ptr_NULL           NULL

-#define png_structp_NULL          NULL

-#define png_uint_16p_NULL         NULL

-#define png_voidp_NULL            NULL

-#define png_write_status_ptr_NULL NULL

-#endif

-

-/* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */

-#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)

-/* Version information for C files, stored in png.c.  This had better match

- * the version above.

- */

-#ifdef PNG_USE_GLOBAL_ARRAYS

-PNG_EXPORT_VAR (PNG_CONST char) png_libpng_ver[18];

-  /* Need room for 99.99.99beta99z */

-#else

-#define png_libpng_ver png_get_header_ver(NULL)

-#endif

-

-#ifdef PNG_USE_GLOBAL_ARRAYS

-/* This was removed in version 1.0.5c */

-/* Structures to facilitate easy interlacing.  See png.c for more details */

-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_start[7];

-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_inc[7];

-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_ystart[7];

-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_yinc[7];

-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_mask[7];

-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_dsp_mask[7];

-/* This isn't currently used.  If you need it, see png.c for more details.

-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_height[7];

-*/

-#endif

-

-#endif /* PNG_NO_EXTERN */

-

-/* Three color definitions.  The order of the red, green, and blue, (and the

- * exact size) is not important, although the size of the fields need to

- * be png_byte or png_uint_16 (as defined below).

- */

-typedef struct png_color_struct

-{

-   png_byte red;

-   png_byte green;

-   png_byte blue;

-} png_color;

-typedef png_color FAR * png_colorp;

-typedef png_color FAR * FAR * png_colorpp;

-

-typedef struct png_color_16_struct

-{

-   png_byte index;    /* used for palette files */

-   png_uint_16 red;   /* for use in red green blue files */

-   png_uint_16 green;

-   png_uint_16 blue;

-   png_uint_16 gray;  /* for use in grayscale files */

-} png_color_16;

-typedef png_color_16 FAR * png_color_16p;

-typedef png_color_16 FAR * FAR * png_color_16pp;

-

-typedef struct png_color_8_struct

-{

-   png_byte red;   /* for use in red green blue files */

-   png_byte green;

-   png_byte blue;

-   png_byte gray;  /* for use in grayscale files */

-   png_byte alpha; /* for alpha channel files */

-} png_color_8;

-typedef png_color_8 FAR * png_color_8p;

-typedef png_color_8 FAR * FAR * png_color_8pp;

-

-/*

- * The following two structures are used for the in-core representation

- * of sPLT chunks.

- */

-typedef struct png_sPLT_entry_struct

-{

-   png_uint_16 red;

-   png_uint_16 green;

-   png_uint_16 blue;

-   png_uint_16 alpha;

-   png_uint_16 frequency;

-} png_sPLT_entry;

-typedef png_sPLT_entry FAR * png_sPLT_entryp;

-typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;

-

-/*  When the depth of the sPLT palette is 8 bits, the color and alpha samples

- *  occupy the LSB of their respective members, and the MSB of each member

- *  is zero-filled.  The frequency member always occupies the full 16 bits.

- */

-

-typedef struct png_sPLT_struct

-{

-   png_charp name;           /* palette name */

-   png_byte depth;           /* depth of palette samples */

-   png_sPLT_entryp entries;  /* palette entries */

-   png_int_32 nentries;      /* number of palette entries */

-} png_sPLT_t;

-typedef png_sPLT_t FAR * png_sPLT_tp;

-typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;

-

-#ifdef PNG_TEXT_SUPPORTED

-/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,

- * and whether that contents is compressed or not.  The "key" field

- * points to a regular zero-terminated C string.  The "text", "lang", and

- * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.

- * However, the * structure returned by png_get_text() will always contain

- * regular zero-terminated C strings (possibly empty), never NULL pointers,

- * so they can be safely used in printf() and other string-handling functions.

- */

-typedef struct png_text_struct

-{

-   int  compression;       /* compression value:

-                             -1: tEXt, none

-                              0: zTXt, deflate

-                              1: iTXt, none

-                              2: iTXt, deflate  */

-   png_charp key;          /* keyword, 1-79 character description of "text" */

-   png_charp text;         /* comment, may be an empty string (ie "")

-                              or a NULL pointer */

-   png_size_t text_length; /* length of the text string */

-#ifdef PNG_iTXt_SUPPORTED

-   png_size_t itxt_length; /* length of the itxt string */

-   png_charp lang;         /* language code, 0-79 characters

-                              or a NULL pointer */

-   png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more

-                              chars or a NULL pointer */

-#endif

-} png_text;

-typedef png_text FAR * png_textp;

-typedef png_text FAR * FAR * png_textpp;

-#endif

-

-/* Supported compression types for text in PNG files (tEXt, and zTXt).

- * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed.

- */

-#define PNG_TEXT_COMPRESSION_NONE_WR -3

-#define PNG_TEXT_COMPRESSION_zTXt_WR -2

-#define PNG_TEXT_COMPRESSION_NONE    -1

-#define PNG_TEXT_COMPRESSION_zTXt     0

-#define PNG_ITXT_COMPRESSION_NONE     1

-#define PNG_ITXT_COMPRESSION_zTXt     2

-#define PNG_TEXT_COMPRESSION_LAST     3  /* Not a valid value */

-

-/* png_time is a way to hold the time in an machine independent way.

- * Two conversions are provided, both from time_t and struct tm.  There

- * is no portable way to convert to either of these structures, as far

- * as I know.  If you know of a portable way, send it to me.  As a side

- * note - PNG has always been Year 2000 compliant!

- */

-typedef struct png_time_struct

-{

-   png_uint_16 year; /* full year, as in, 1995 */

-   png_byte month;   /* month of year, 1 - 12 */

-   png_byte day;     /* day of month, 1 - 31 */

-   png_byte hour;    /* hour of day, 0 - 23 */

-   png_byte minute;  /* minute of hour, 0 - 59 */

-   png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */

-} png_time;

-typedef png_time FAR * png_timep;

-typedef png_time FAR * FAR * png_timepp;

-

-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \

- defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)

-/* png_unknown_chunk is a structure to hold queued chunks for which there is

- * no specific support.  The idea is that we can use this to queue

- * up private chunks for output even though the library doesn't actually

- * know about their semantics.

- */

-#define PNG_CHUNK_NAME_LENGTH 5

-typedef struct png_unknown_chunk_t

-{

-    png_byte name[PNG_CHUNK_NAME_LENGTH];

-    png_byte *data;

-    png_size_t size;

-

-    /* libpng-using applications should NOT directly modify this byte. */

-    png_byte location; /* mode of operation at read time */

-}

-png_unknown_chunk;

-typedef png_unknown_chunk FAR * png_unknown_chunkp;

-typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;

-#endif

-

-/* png_info is a structure that holds the information in a PNG file so

- * that the application can find out the characteristics of the image.

- * If you are reading the file, this structure will tell you what is

- * in the PNG file.  If you are writing the file, fill in the information

- * you want to put into the PNG file, then call png_write_info().

- * The names chosen should be very close to the PNG specification, so

- * consult that document for information about the meaning of each field.

- *

- * With libpng < 0.95, it was only possible to directly set and read the

- * the values in the png_info_struct, which meant that the contents and

- * order of the values had to remain fixed.  With libpng 0.95 and later,

- * however, there are now functions that abstract the contents of

- * png_info_struct from the application, so this makes it easier to use

- * libpng with dynamic libraries, and even makes it possible to use

- * libraries that don't have all of the libpng ancillary chunk-handing

- * functionality.

- *

- * In any case, the order of the parameters in png_info_struct should NOT

- * be changed for as long as possible to keep compatibility with applications

- * that use the old direct-access method with png_info_struct.

- *

- * The following members may have allocated storage attached that should be

- * cleaned up before the structure is discarded: palette, trans, text,

- * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,

- * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these

- * are automatically freed when the info structure is deallocated, if they were

- * allocated internally by libpng.  This behavior can be changed by means

- * of the png_data_freer() function.

- *

- * More allocation details: all the chunk-reading functions that

- * change these members go through the corresponding png_set_*

- * functions.  A function to clear these members is available: see

- * png_free_data().  The png_set_* functions do not depend on being

- * able to point info structure members to any of the storage they are

- * passed (they make their own copies), EXCEPT that the png_set_text

- * functions use the same storage passed to them in the text_ptr or

- * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns

- * functions do not make their own copies.

- */

-typedef struct png_info_struct

-{

-   /* The following are necessary for every PNG file */

-   png_uint_32 width PNG_DEPSTRUCT;       /* width of image in pixels (from IHDR) */

-   png_uint_32 height PNG_DEPSTRUCT;      /* height of image in pixels (from IHDR) */

-   png_uint_32 valid PNG_DEPSTRUCT;       /* valid chunk data (see PNG_INFO_ below) */

-   png_uint_32 rowbytes PNG_DEPSTRUCT;    /* bytes needed to hold an untransformed row */

-   png_colorp palette PNG_DEPSTRUCT;      /* array of color values (valid & PNG_INFO_PLTE) */

-   png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in "palette" (PLTE) */

-   png_uint_16 num_trans PNG_DEPSTRUCT;   /* number of transparent palette color (tRNS) */

-   png_byte bit_depth PNG_DEPSTRUCT;      /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */

-   png_byte color_type PNG_DEPSTRUCT;     /* see PNG_COLOR_TYPE_ below (from IHDR) */

-   /* The following three should have been named *_method not *_type */

-   png_byte compression_type PNG_DEPSTRUCT; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */

-   png_byte filter_type PNG_DEPSTRUCT;    /* must be PNG_FILTER_TYPE_BASE (from IHDR) */

-   png_byte interlace_type PNG_DEPSTRUCT; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */

-

-   /* The following is informational only on read, and not used on writes. */

-   png_byte channels PNG_DEPSTRUCT;       /* number of data channels per pixel (1, 2, 3, 4) */

-   png_byte pixel_depth PNG_DEPSTRUCT;    /* number of bits per pixel */

-   png_byte spare_byte PNG_DEPSTRUCT;     /* to align the data, and for future use */

-   png_byte signature[8] PNG_DEPSTRUCT;   /* magic bytes read by libpng from start of file */

-

-   /* The rest of the data is optional.  If you are reading, check the

-    * valid field to see if the information in these are valid.  If you

-    * are writing, set the valid field to those chunks you want written,

-    * and initialize the appropriate fields below.

-    */

-

-#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

-   /* The gAMA chunk describes the gamma characteristics of the system

-    * on which the image was created, normally in the range [1.0, 2.5].

-    * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.

-    */

-   float gamma PNG_DEPSTRUCT; /* gamma value of image, if (valid & PNG_INFO_gAMA) */

-#endif

-

-#ifdef PNG_sRGB_SUPPORTED

-    /* GR-P, 0.96a */

-    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */

-   png_byte srgb_intent PNG_DEPSTRUCT; /* sRGB rendering intent [0, 1, 2, or 3] */

-#endif

-

-#ifdef PNG_TEXT_SUPPORTED

-   /* The tEXt, and zTXt chunks contain human-readable textual data in

-    * uncompressed, compressed, and optionally compressed forms, respectively.

-    * The data in "text" is an array of pointers to uncompressed,

-    * null-terminated C strings. Each chunk has a keyword that describes the

-    * textual data contained in that chunk.  Keywords are not required to be

-    * unique, and the text string may be empty.  Any number of text chunks may

-    * be in an image.

-    */

-   int num_text PNG_DEPSTRUCT; /* number of comments read/to write */

-   int max_text PNG_DEPSTRUCT; /* current size of text array */

-   png_textp text PNG_DEPSTRUCT; /* array of comments read/to write */

-#endif /* PNG_TEXT_SUPPORTED */

-

-#ifdef PNG_tIME_SUPPORTED

-   /* The tIME chunk holds the last time the displayed image data was

-    * modified.  See the png_time struct for the contents of this struct.

-    */

-   png_time mod_time PNG_DEPSTRUCT;

-#endif

-

-#ifdef PNG_sBIT_SUPPORTED

-   /* The sBIT chunk specifies the number of significant high-order bits

-    * in the pixel data.  Values are in the range [1, bit_depth], and are

-    * only specified for the channels in the pixel data.  The contents of

-    * the low-order bits is not specified.  Data is valid if

-    * (valid & PNG_INFO_sBIT) is non-zero.

-    */

-   png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in color channels */

-#endif

-

-#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \

-defined(PNG_READ_BACKGROUND_SUPPORTED)

-   /* The tRNS chunk supplies transparency data for paletted images and

-    * other image types that don't need a full alpha channel.  There are

-    * "num_trans" transparency values for a paletted image, stored in the

-    * same order as the palette colors, starting from index 0.  Values

-    * for the data are in the range [0, 255], ranging from fully transparent

-    * to fully opaque, respectively.  For non-paletted images, there is a

-    * single color specified that should be treated as fully transparent.

-    * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.

-    */

-   png_bytep trans PNG_DEPSTRUCT; /* transparent values for paletted image */

-   png_color_16 trans_values PNG_DEPSTRUCT; /* transparent color for non-palette image */

-#endif

-

-#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   /* The bKGD chunk gives the suggested image background color if the

-    * display program does not have its own background color and the image

-    * is needs to composited onto a background before display.  The colors

-    * in "background" are normally in the same color space/depth as the

-    * pixel data.  Data is valid if (valid & PNG_INFO_bKGD) is non-zero.

-    */

-   png_color_16 background PNG_DEPSTRUCT;

-#endif

-

-#ifdef PNG_oFFs_SUPPORTED

-   /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards

-    * and downwards from the top-left corner of the display, page, or other

-    * application-specific co-ordinate space.  See the PNG_OFFSET_ defines

-    * below for the unit types.  Valid if (valid & PNG_INFO_oFFs) non-zero.

-    */

-   png_int_32 x_offset PNG_DEPSTRUCT; /* x offset on page */

-   png_int_32 y_offset PNG_DEPSTRUCT; /* y offset on page */

-   png_byte offset_unit_type PNG_DEPSTRUCT; /* offset units type */

-#endif

-

-#ifdef PNG_pHYs_SUPPORTED

-   /* The pHYs chunk gives the physical pixel density of the image for

-    * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_

-    * defines below).  Data is valid if (valid & PNG_INFO_pHYs) is non-zero.

-    */

-   png_uint_32 x_pixels_per_unit PNG_DEPSTRUCT; /* horizontal pixel density */

-   png_uint_32 y_pixels_per_unit PNG_DEPSTRUCT; /* vertical pixel density */

-   png_byte phys_unit_type PNG_DEPSTRUCT; /* resolution type (see PNG_RESOLUTION_ below) */

-#endif

-

-#ifdef PNG_hIST_SUPPORTED

-   /* The hIST chunk contains the relative frequency or importance of the

-    * various palette entries, so that a viewer can intelligently select a

-    * reduced-color palette, if required.  Data is an array of "num_palette"

-    * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)

-    * is non-zero.

-    */

-   png_uint_16p hist PNG_DEPSTRUCT;

-#endif

-

-#ifdef PNG_cHRM_SUPPORTED

-   /* The cHRM chunk describes the CIE color characteristics of the monitor

-    * on which the PNG was created.  This data allows the viewer to do gamut

-    * mapping of the input image to ensure that the viewer sees the same

-    * colors in the image as the creator.  Values are in the range

-    * [0.0, 0.8].  Data valid if (valid & PNG_INFO_cHRM) non-zero.

-    */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   float x_white PNG_DEPSTRUCT;

-   float y_white PNG_DEPSTRUCT;

-   float x_red PNG_DEPSTRUCT;

-   float y_red PNG_DEPSTRUCT;

-   float x_green PNG_DEPSTRUCT;

-   float y_green PNG_DEPSTRUCT;

-   float x_blue PNG_DEPSTRUCT;

-   float y_blue PNG_DEPSTRUCT;

-#endif

-#endif

-

-#ifdef PNG_pCAL_SUPPORTED

-   /* The pCAL chunk describes a transformation between the stored pixel

-    * values and original physical data values used to create the image.

-    * The integer range [0, 2^bit_depth - 1] maps to the floating-point

-    * range given by [pcal_X0, pcal_X1], and are further transformed by a

-    * (possibly non-linear) transformation function given by "pcal_type"

-    * and "pcal_params" into "pcal_units".  Please see the PNG_EQUATION_

-    * defines below, and the PNG-Group's PNG extensions document for a

-    * complete description of the transformations and how they should be

-    * implemented, and for a description of the ASCII parameter strings.

-    * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.

-    */

-   png_charp pcal_purpose PNG_DEPSTRUCT;  /* pCAL chunk description string */

-   png_int_32 pcal_X0 PNG_DEPSTRUCT;      /* minimum value */

-   png_int_32 pcal_X1 PNG_DEPSTRUCT;      /* maximum value */

-   png_charp pcal_units PNG_DEPSTRUCT;    /* Latin-1 string giving physical units */

-   png_charpp pcal_params PNG_DEPSTRUCT;  /* ASCII strings containing parameter values */

-   png_byte pcal_type PNG_DEPSTRUCT;      /* equation type (see PNG_EQUATION_ below) */

-   png_byte pcal_nparams PNG_DEPSTRUCT;   /* number of parameters given in pcal_params */

-#endif

-

-/* New members added in libpng-1.0.6 */

-#ifdef PNG_FREE_ME_SUPPORTED

-   png_uint_32 free_me PNG_DEPSTRUCT;     /* flags items libpng is responsible for freeing */

-#endif

-

-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \

- defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)

-   /* Storage for unknown chunks that the library doesn't recognize. */

-   png_unknown_chunkp unknown_chunks PNG_DEPSTRUCT;

-   png_size_t unknown_chunks_num PNG_DEPSTRUCT;

-#endif

-

-#ifdef PNG_iCCP_SUPPORTED

-   /* iCCP chunk data. */

-   png_charp iccp_name PNG_DEPSTRUCT;     /* profile name */

-   png_charp iccp_profile PNG_DEPSTRUCT;  /* International Color Consortium profile data */

-                            /* Note to maintainer: should be png_bytep */

-   png_uint_32 iccp_proflen PNG_DEPSTRUCT;  /* ICC profile data length */

-   png_byte iccp_compression PNG_DEPSTRUCT; /* Always zero */

-#endif

-

-#ifdef PNG_sPLT_SUPPORTED

-   /* Data on sPLT chunks (there may be more than one). */

-   png_sPLT_tp splt_palettes PNG_DEPSTRUCT;

-   png_uint_32 splt_palettes_num PNG_DEPSTRUCT;

-#endif

-

-#ifdef PNG_sCAL_SUPPORTED

-   /* The sCAL chunk describes the actual physical dimensions of the

-    * subject matter of the graphic.  The chunk contains a unit specification

-    * a byte value, and two ASCII strings representing floating-point

-    * values.  The values are width and height corresponsing to one pixel

-    * in the image.  This external representation is converted to double

-    * here.  Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.

-    */

-   png_byte scal_unit PNG_DEPSTRUCT;         /* unit of physical scale */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   double scal_pixel_width PNG_DEPSTRUCT;    /* width of one pixel */

-   double scal_pixel_height PNG_DEPSTRUCT;   /* height of one pixel */

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   png_charp scal_s_width PNG_DEPSTRUCT;     /* string containing height */

-   png_charp scal_s_height PNG_DEPSTRUCT;    /* string containing width */

-#endif

-#endif

-

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-   /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */

-   /* Data valid if (valid & PNG_INFO_IDAT) non-zero */

-   png_bytepp row_pointers PNG_DEPSTRUCT;        /* the image bits */

-#endif

-

-#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED)

-   png_fixed_point int_gamma PNG_DEPSTRUCT; /* gamma of image, if (valid & PNG_INFO_gAMA) */

-#endif

-

-#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED)

-   png_fixed_point int_x_white PNG_DEPSTRUCT;

-   png_fixed_point int_y_white PNG_DEPSTRUCT;

-   png_fixed_point int_x_red PNG_DEPSTRUCT;

-   png_fixed_point int_y_red PNG_DEPSTRUCT;

-   png_fixed_point int_x_green PNG_DEPSTRUCT;

-   png_fixed_point int_y_green PNG_DEPSTRUCT;

-   png_fixed_point int_x_blue PNG_DEPSTRUCT;

-   png_fixed_point int_y_blue PNG_DEPSTRUCT;

-#endif

-

-} png_info;

-

-typedef png_info FAR * png_infop;

-typedef png_info FAR * FAR * png_infopp;

-

-/* Maximum positive integer used in PNG is (2^31)-1 */

-#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)

-#define PNG_UINT_32_MAX ((png_uint_32)(-1))

-#define PNG_SIZE_MAX ((png_size_t)(-1))

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-/* PNG_MAX_UINT is deprecated; use PNG_UINT_31_MAX instead. */

-#define PNG_MAX_UINT PNG_UINT_31_MAX

-#endif

-

-/* These describe the color_type field in png_info. */

-/* color type masks */

-#define PNG_COLOR_MASK_PALETTE    1

-#define PNG_COLOR_MASK_COLOR      2

-#define PNG_COLOR_MASK_ALPHA      4

-

-/* color types.  Note that not all combinations are legal */

-#define PNG_COLOR_TYPE_GRAY 0

-#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)

-#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)

-#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)

-#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)

-/* aliases */

-#define PNG_COLOR_TYPE_RGBA  PNG_COLOR_TYPE_RGB_ALPHA

-#define PNG_COLOR_TYPE_GA  PNG_COLOR_TYPE_GRAY_ALPHA

-

-/* This is for compression type. PNG 1.0-1.2 only define the single type. */

-#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */

-#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE

-

-/* This is for filter type. PNG 1.0-1.2 only define the single type. */

-#define PNG_FILTER_TYPE_BASE      0 /* Single row per-byte filtering */

-#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */

-#define PNG_FILTER_TYPE_DEFAULT   PNG_FILTER_TYPE_BASE

-

-/* These are for the interlacing type.  These values should NOT be changed. */

-#define PNG_INTERLACE_NONE        0 /* Non-interlaced image */

-#define PNG_INTERLACE_ADAM7       1 /* Adam7 interlacing */

-#define PNG_INTERLACE_LAST        2 /* Not a valid value */

-

-/* These are for the oFFs chunk.  These values should NOT be changed. */

-#define PNG_OFFSET_PIXEL          0 /* Offset in pixels */

-#define PNG_OFFSET_MICROMETER     1 /* Offset in micrometers (1/10^6 meter) */

-#define PNG_OFFSET_LAST           2 /* Not a valid value */

-

-/* These are for the pCAL chunk.  These values should NOT be changed. */

-#define PNG_EQUATION_LINEAR       0 /* Linear transformation */

-#define PNG_EQUATION_BASE_E       1 /* Exponential base e transform */

-#define PNG_EQUATION_ARBITRARY    2 /* Arbitrary base exponential transform */

-#define PNG_EQUATION_HYPERBOLIC   3 /* Hyperbolic sine transformation */

-#define PNG_EQUATION_LAST         4 /* Not a valid value */

-

-/* These are for the sCAL chunk.  These values should NOT be changed. */

-#define PNG_SCALE_UNKNOWN         0 /* unknown unit (image scale) */

-#define PNG_SCALE_METER           1 /* meters per pixel */

-#define PNG_SCALE_RADIAN          2 /* radians per pixel */

-#define PNG_SCALE_LAST            3 /* Not a valid value */

-

-/* These are for the pHYs chunk.  These values should NOT be changed. */

-#define PNG_RESOLUTION_UNKNOWN    0 /* pixels/unknown unit (aspect ratio) */

-#define PNG_RESOLUTION_METER      1 /* pixels/meter */

-#define PNG_RESOLUTION_LAST       2 /* Not a valid value */

-

-/* These are for the sRGB chunk.  These values should NOT be changed. */

-#define PNG_sRGB_INTENT_PERCEPTUAL 0

-#define PNG_sRGB_INTENT_RELATIVE   1

-#define PNG_sRGB_INTENT_SATURATION 2

-#define PNG_sRGB_INTENT_ABSOLUTE   3

-#define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */

-

-/* This is for text chunks */

-#define PNG_KEYWORD_MAX_LENGTH     79

-

-/* Maximum number of entries in PLTE/sPLT/tRNS arrays */

-#define PNG_MAX_PALETTE_LENGTH    256

-

-/* These determine if an ancillary chunk's data has been successfully read

- * from the PNG header, or if the application has filled in the corresponding

- * data in the info_struct to be written into the output file.  The values

- * of the PNG_INFO_<chunk> defines should NOT be changed.

- */

-#define PNG_INFO_gAMA 0x0001

-#define PNG_INFO_sBIT 0x0002

-#define PNG_INFO_cHRM 0x0004

-#define PNG_INFO_PLTE 0x0008

-#define PNG_INFO_tRNS 0x0010

-#define PNG_INFO_bKGD 0x0020

-#define PNG_INFO_hIST 0x0040

-#define PNG_INFO_pHYs 0x0080

-#define PNG_INFO_oFFs 0x0100

-#define PNG_INFO_tIME 0x0200

-#define PNG_INFO_pCAL 0x0400

-#define PNG_INFO_sRGB 0x0800   /* GR-P, 0.96a */

-#define PNG_INFO_iCCP 0x1000   /* ESR, 1.0.6 */

-#define PNG_INFO_sPLT 0x2000   /* ESR, 1.0.6 */

-#define PNG_INFO_sCAL 0x4000   /* ESR, 1.0.6 */

-#define PNG_INFO_IDAT 0x8000L  /* ESR, 1.0.6 */

-

-/* This is used for the transformation routines, as some of them

- * change these values for the row.  It also should enable using

- * the routines for other purposes.

- */

-typedef struct png_row_info_struct

-{

-   png_uint_32 width; /* width of row */

-   png_uint_32 rowbytes; /* number of bytes in row */

-   png_byte color_type; /* color type of row */

-   png_byte bit_depth; /* bit depth of row */

-   png_byte channels; /* number of channels (1, 2, 3, or 4) */

-   png_byte pixel_depth; /* bits per pixel (depth * channels) */

-} png_row_info;

-

-typedef png_row_info FAR * png_row_infop;

-typedef png_row_info FAR * FAR * png_row_infopp;

-

-/* These are the function types for the I/O functions and for the functions

- * that allow the user to override the default I/O functions with his or her

- * own.  The png_error_ptr type should match that of user-supplied warning

- * and error functions, while the png_rw_ptr type should match that of the

- * user read/write data functions.

- */

-typedef struct png_struct_def png_struct;

-typedef png_struct FAR * png_structp;

-

-typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));

-typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));

-typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));

-typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,

-   int));

-typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,

-   int));

-

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop));

-typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));

-typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,

-   png_uint_32, int));

-#endif

-

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_LEGACY_SUPPORTED)

-typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,

-    png_row_infop, png_bytep));

-#endif

-

-#ifdef PNG_USER_CHUNKS_SUPPORTED

-typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));

-#endif

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));

-#endif

-

-/* Transform masks for the high-level interface */

-#define PNG_TRANSFORM_IDENTITY       0x0000    /* read and write */

-#define PNG_TRANSFORM_STRIP_16       0x0001    /* read only */

-#define PNG_TRANSFORM_STRIP_ALPHA    0x0002    /* read only */

-#define PNG_TRANSFORM_PACKING        0x0004    /* read and write */

-#define PNG_TRANSFORM_PACKSWAP       0x0008    /* read and write */

-#define PNG_TRANSFORM_EXPAND         0x0010    /* read only */

-#define PNG_TRANSFORM_INVERT_MONO    0x0020    /* read and write */

-#define PNG_TRANSFORM_SHIFT          0x0040    /* read and write */

-#define PNG_TRANSFORM_BGR            0x0080    /* read and write */

-#define PNG_TRANSFORM_SWAP_ALPHA     0x0100    /* read and write */

-#define PNG_TRANSFORM_SWAP_ENDIAN    0x0200    /* read and write */

-#define PNG_TRANSFORM_INVERT_ALPHA   0x0400    /* read and write */

-#define PNG_TRANSFORM_STRIP_FILLER   0x0800    /* write only, deprecated */

-/* Added to libpng-1.2.34 */

-#define PNG_TRANSFORM_STRIP_FILLER_BEFORE 0x0800  /* write only */

-#define PNG_TRANSFORM_STRIP_FILLER_AFTER  0x1000  /* write only */

-/* Added to libpng-1.2.41 */

-#define PNG_TRANSFORM_GRAY_TO_RGB   0x2000      /* read only */

-

-/* Flags for MNG supported features */

-#define PNG_FLAG_MNG_EMPTY_PLTE     0x01

-#define PNG_FLAG_MNG_FILTER_64      0x04

-#define PNG_ALL_MNG_FEATURES        0x05

-

-typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t));

-typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));

-

-/* The structure that holds the information to read and write PNG files.

- * The only people who need to care about what is inside of this are the

- * people who will be modifying the library for their own special needs.

- * It should NOT be accessed directly by an application, except to store

- * the jmp_buf.

- */

-

-struct png_struct_def

-{

-#ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf jmpbuf;            /* used in png_error */

-#endif

-   png_error_ptr error_fn PNG_DEPSTRUCT;    /* function for printing errors and aborting */

-   png_error_ptr warning_fn PNG_DEPSTRUCT;  /* function for printing warnings */

-   png_voidp error_ptr PNG_DEPSTRUCT;       /* user supplied struct for error functions */

-   png_rw_ptr write_data_fn PNG_DEPSTRUCT;  /* function for writing output data */

-   png_rw_ptr read_data_fn PNG_DEPSTRUCT;   /* function for reading input data */

-   png_voidp io_ptr PNG_DEPSTRUCT;          /* ptr to application struct for I/O functions */

-

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-   png_user_transform_ptr read_user_transform_fn PNG_DEPSTRUCT; /* user read transform */

-#endif

-

-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-   png_user_transform_ptr write_user_transform_fn PNG_DEPSTRUCT; /* user write transform */

-#endif

-

-/* These were added in libpng-1.0.2 */

-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

-   png_voidp user_transform_ptr PNG_DEPSTRUCT; /* user supplied struct for user transform */

-   png_byte user_transform_depth PNG_DEPSTRUCT;    /* bit depth of user transformed pixels */

-   png_byte user_transform_channels PNG_DEPSTRUCT; /* channels in user transformed pixels */

-#endif

-#endif

-

-   png_uint_32 mode PNG_DEPSTRUCT;          /* tells us where we are in the PNG file */

-   png_uint_32 flags PNG_DEPSTRUCT;         /* flags indicating various things to libpng */

-   png_uint_32 transformations PNG_DEPSTRUCT; /* which transformations to perform */

-

-   z_stream zstream PNG_DEPSTRUCT;          /* pointer to decompression structure (below) */

-   png_bytep zbuf PNG_DEPSTRUCT;            /* buffer for zlib */

-   png_size_t zbuf_size PNG_DEPSTRUCT;      /* size of zbuf */

-   int zlib_level PNG_DEPSTRUCT;            /* holds zlib compression level */

-   int zlib_method PNG_DEPSTRUCT;           /* holds zlib compression method */

-   int zlib_window_bits PNG_DEPSTRUCT;      /* holds zlib compression window bits */

-   int zlib_mem_level PNG_DEPSTRUCT;        /* holds zlib compression memory level */

-   int zlib_strategy PNG_DEPSTRUCT;         /* holds zlib compression strategy */

-

-   png_uint_32 width PNG_DEPSTRUCT;         /* width of image in pixels */

-   png_uint_32 height PNG_DEPSTRUCT;        /* height of image in pixels */

-   png_uint_32 num_rows PNG_DEPSTRUCT;      /* number of rows in current pass */

-   png_uint_32 usr_width PNG_DEPSTRUCT;     /* width of row at start of write */

-   png_uint_32 rowbytes PNG_DEPSTRUCT;      /* size of row in bytes */

-   png_uint_32 irowbytes PNG_DEPSTRUCT;     /* size of current interlaced row in bytes */

-   png_uint_32 iwidth PNG_DEPSTRUCT;        /* width of current interlaced row in pixels */

-   png_uint_32 row_number PNG_DEPSTRUCT;    /* current row in interlace pass */

-   png_bytep prev_row PNG_DEPSTRUCT;        /* buffer to save previous (unfiltered) row */

-   png_bytep row_buf PNG_DEPSTRUCT;         /* buffer to save current (unfiltered) row */

-#ifndef PNG_NO_WRITE_FILTER

-   png_bytep sub_row PNG_DEPSTRUCT;         /* buffer to save "sub" row when filtering */

-   png_bytep up_row PNG_DEPSTRUCT;          /* buffer to save "up" row when filtering */

-   png_bytep avg_row PNG_DEPSTRUCT;         /* buffer to save "avg" row when filtering */

-   png_bytep paeth_row PNG_DEPSTRUCT;       /* buffer to save "Paeth" row when filtering */

-#endif

-   png_row_info row_info PNG_DEPSTRUCT;     /* used for transformation routines */

-

-   png_uint_32 idat_size PNG_DEPSTRUCT;     /* current IDAT size for read */

-   png_uint_32 crc PNG_DEPSTRUCT;           /* current chunk CRC value */

-   png_colorp palette PNG_DEPSTRUCT;        /* palette from the input file */

-   png_uint_16 num_palette PNG_DEPSTRUCT;   /* number of color entries in palette */

-   png_uint_16 num_trans PNG_DEPSTRUCT;     /* number of transparency values */

-   png_byte chunk_name[5] PNG_DEPSTRUCT;    /* null-terminated name of current chunk */

-   png_byte compression PNG_DEPSTRUCT;      /* file compression type (always 0) */

-   png_byte filter PNG_DEPSTRUCT;           /* file filter type (always 0) */

-   png_byte interlaced PNG_DEPSTRUCT;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */

-   png_byte pass PNG_DEPSTRUCT;             /* current interlace pass (0 - 6) */

-   png_byte do_filter PNG_DEPSTRUCT;        /* row filter flags (see PNG_FILTER_ below ) */

-   png_byte color_type PNG_DEPSTRUCT;       /* color type of file */

-   png_byte bit_depth PNG_DEPSTRUCT;        /* bit depth of file */

-   png_byte usr_bit_depth PNG_DEPSTRUCT;    /* bit depth of users row */

-   png_byte pixel_depth PNG_DEPSTRUCT;      /* number of bits per pixel */

-   png_byte channels PNG_DEPSTRUCT;         /* number of channels in file */

-   png_byte usr_channels PNG_DEPSTRUCT;     /* channels at start of write */

-   png_byte sig_bytes PNG_DEPSTRUCT;        /* magic bytes read/written from start of file */

-

-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

-#ifdef PNG_LEGACY_SUPPORTED

-   png_byte filler PNG_DEPSTRUCT;           /* filler byte for pixel expansion */

-#else

-   png_uint_16 filler PNG_DEPSTRUCT;           /* filler bytes for pixel expansion */

-#endif

-#endif

-

-#ifdef PNG_bKGD_SUPPORTED

-   png_byte background_gamma_type PNG_DEPSTRUCT;

-#  ifdef PNG_FLOATING_POINT_SUPPORTED

-   float background_gamma PNG_DEPSTRUCT;

-#  endif

-   png_color_16 background PNG_DEPSTRUCT;   /* background color in screen gamma space */

-#ifdef PNG_READ_GAMMA_SUPPORTED

-   png_color_16 background_1 PNG_DEPSTRUCT; /* background normalized to gamma 1.0 */

-#endif

-#endif /* PNG_bKGD_SUPPORTED */

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-   png_flush_ptr output_flush_fn PNG_DEPSTRUCT; /* Function for flushing output */

-   png_uint_32 flush_dist PNG_DEPSTRUCT;    /* how many rows apart to flush, 0 - no flush */

-   png_uint_32 flush_rows PNG_DEPSTRUCT;    /* number of rows written since last flush */

-#endif

-

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   int gamma_shift PNG_DEPSTRUCT;      /* number of "insignificant" bits 16-bit gamma */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   float gamma PNG_DEPSTRUCT;          /* file gamma value */

-   float screen_gamma PNG_DEPSTRUCT;   /* screen gamma value (display_exponent) */

-#endif

-#endif

-

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   png_bytep gamma_table PNG_DEPSTRUCT;     /* gamma table for 8-bit depth files */

-   png_bytep gamma_from_1 PNG_DEPSTRUCT;    /* converts from 1.0 to screen */

-   png_bytep gamma_to_1 PNG_DEPSTRUCT;      /* converts from file to 1.0 */

-   png_uint_16pp gamma_16_table PNG_DEPSTRUCT; /* gamma table for 16-bit depth files */

-   png_uint_16pp gamma_16_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to screen */

-   png_uint_16pp gamma_16_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */

-#endif

-

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)

-   png_color_8 sig_bit PNG_DEPSTRUCT;       /* significant bits in each available channel */

-#endif

-

-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

-   png_color_8 shift PNG_DEPSTRUCT;         /* shift for significant bit tranformation */

-#endif

-

-#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \

- || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   png_bytep trans PNG_DEPSTRUCT;           /* transparency values for paletted files */

-   png_color_16 trans_values PNG_DEPSTRUCT; /* transparency values for non-paletted files */

-#endif

-

-   png_read_status_ptr read_row_fn PNG_DEPSTRUCT;   /* called after each row is decoded */

-   png_write_status_ptr write_row_fn PNG_DEPSTRUCT; /* called after each row is encoded */

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-   png_progressive_info_ptr info_fn PNG_DEPSTRUCT; /* called after header data fully read */

-   png_progressive_row_ptr row_fn PNG_DEPSTRUCT;   /* called after each prog. row is decoded */

-   png_progressive_end_ptr end_fn PNG_DEPSTRUCT;   /* called after image is complete */

-   png_bytep save_buffer_ptr PNG_DEPSTRUCT;        /* current location in save_buffer */

-   png_bytep save_buffer PNG_DEPSTRUCT;            /* buffer for previously read data */

-   png_bytep current_buffer_ptr PNG_DEPSTRUCT;     /* current location in current_buffer */

-   png_bytep current_buffer PNG_DEPSTRUCT;         /* buffer for recently used data */

-   png_uint_32 push_length PNG_DEPSTRUCT;          /* size of current input chunk */

-   png_uint_32 skip_length PNG_DEPSTRUCT;          /* bytes to skip in input data */

-   png_size_t save_buffer_size PNG_DEPSTRUCT;      /* amount of data now in save_buffer */

-   png_size_t save_buffer_max PNG_DEPSTRUCT;       /* total size of save_buffer */

-   png_size_t buffer_size PNG_DEPSTRUCT;           /* total amount of available input data */

-   png_size_t current_buffer_size PNG_DEPSTRUCT;   /* amount of data now in current_buffer */

-   int process_mode PNG_DEPSTRUCT;                 /* what push library is currently doing */

-   int cur_palette PNG_DEPSTRUCT;                  /* current push library palette index */

-

-#  ifdef PNG_TEXT_SUPPORTED

-     png_size_t current_text_size PNG_DEPSTRUCT;   /* current size of text input data */

-     png_size_t current_text_left PNG_DEPSTRUCT;   /* how much text left to read in input */

-     png_charp current_text PNG_DEPSTRUCT;         /* current text chunk buffer */

-     png_charp current_text_ptr PNG_DEPSTRUCT;     /* current location in current_text */

-#  endif /* PNG_TEXT_SUPPORTED */

-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

-

-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)

-/* for the Borland special 64K segment handler */

-   png_bytepp offset_table_ptr PNG_DEPSTRUCT;

-   png_bytep offset_table PNG_DEPSTRUCT;

-   png_uint_16 offset_table_number PNG_DEPSTRUCT;

-   png_uint_16 offset_table_count PNG_DEPSTRUCT;

-   png_uint_16 offset_table_count_free PNG_DEPSTRUCT;

-#endif

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-   png_bytep palette_lookup PNG_DEPSTRUCT;         /* lookup table for dithering */

-   png_bytep dither_index PNG_DEPSTRUCT;           /* index translation for palette files */

-#endif

-

-#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED)

-   png_uint_16p hist PNG_DEPSTRUCT;                /* histogram */

-#endif

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   png_byte heuristic_method PNG_DEPSTRUCT;        /* heuristic for row filter selection */

-   png_byte num_prev_filters PNG_DEPSTRUCT;        /* number of weights for previous rows */

-   png_bytep prev_filters PNG_DEPSTRUCT;           /* filter type(s) of previous row(s) */

-   png_uint_16p filter_weights PNG_DEPSTRUCT;      /* weight(s) for previous line(s) */

-   png_uint_16p inv_filter_weights PNG_DEPSTRUCT;  /* 1/weight(s) for previous line(s) */

-   png_uint_16p filter_costs PNG_DEPSTRUCT;        /* relative filter calculation cost */

-   png_uint_16p inv_filter_costs PNG_DEPSTRUCT;    /* 1/relative filter calculation cost */

-#endif

-

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-   png_charp time_buffer PNG_DEPSTRUCT;            /* String to hold RFC 1123 time text */

-#endif

-

-/* New members added in libpng-1.0.6 */

-

-#ifdef PNG_FREE_ME_SUPPORTED

-   png_uint_32 free_me PNG_DEPSTRUCT;   /* flags items libpng is responsible for freeing */

-#endif

-

-#ifdef PNG_USER_CHUNKS_SUPPORTED

-   png_voidp user_chunk_ptr PNG_DEPSTRUCT;

-   png_user_chunk_ptr read_user_chunk_fn PNG_DEPSTRUCT; /* user read chunk handler */

-#endif

-

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-   int num_chunk_list PNG_DEPSTRUCT;

-   png_bytep chunk_list PNG_DEPSTRUCT;

-#endif

-

-/* New members added in libpng-1.0.3 */

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-   png_byte rgb_to_gray_status PNG_DEPSTRUCT;

-   /* These were changed from png_byte in libpng-1.0.6 */

-   png_uint_16 rgb_to_gray_red_coeff PNG_DEPSTRUCT;

-   png_uint_16 rgb_to_gray_green_coeff PNG_DEPSTRUCT;

-   png_uint_16 rgb_to_gray_blue_coeff PNG_DEPSTRUCT;

-#endif

-

-/* New member added in libpng-1.0.4 (renamed in 1.0.9) */

-#if defined(PNG_MNG_FEATURES_SUPPORTED) || \

-    defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \

-    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)

-/* Changed from png_byte to png_uint_32 at version 1.2.0 */

-#ifdef PNG_1_0_X

-   png_byte mng_features_permitted PNG_DEPSTRUCT;

-#else

-   png_uint_32 mng_features_permitted PNG_DEPSTRUCT;

-#endif /* PNG_1_0_X */

-#endif

-

-/* New member added in libpng-1.0.7 */

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   png_fixed_point int_gamma PNG_DEPSTRUCT;

-#endif

-

-/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   png_byte filter_type PNG_DEPSTRUCT;

-#endif

-

-#ifdef PNG_1_0_X

-/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */

-   png_uint_32 row_buf_size PNG_DEPSTRUCT;

-#endif

-

-/* New members added in libpng-1.2.0 */

-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

-#  ifndef PNG_1_0_X

-#    ifdef PNG_MMX_CODE_SUPPORTED

-   png_byte     mmx_bitdepth_threshold PNG_DEPSTRUCT;

-   png_uint_32  mmx_rowbytes_threshold PNG_DEPSTRUCT;

-#    endif

-   png_uint_32  asm_flags PNG_DEPSTRUCT;

-#  endif

-#endif

-

-/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_voidp mem_ptr PNG_DEPSTRUCT;            /* user supplied struct for mem functions */

-   png_malloc_ptr malloc_fn PNG_DEPSTRUCT;     /* function for allocating memory */

-   png_free_ptr free_fn PNG_DEPSTRUCT;         /* function for freeing memory */

-#endif

-

-/* New member added in libpng-1.0.13 and 1.2.0 */

-   png_bytep big_row_buf PNG_DEPSTRUCT;        /* buffer to save current (unfiltered) row */

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-/* The following three members were added at version 1.0.14 and 1.2.4 */

-   png_bytep dither_sort PNG_DEPSTRUCT;        /* working sort array */

-   png_bytep index_to_palette PNG_DEPSTRUCT;   /* where the original index currently is */

-                                 /* in the palette */

-   png_bytep palette_to_index PNG_DEPSTRUCT;   /* which original index points to this */

-                                 /* palette color */

-#endif

-

-/* New members added in libpng-1.0.16 and 1.2.6 */

-   png_byte compression_type PNG_DEPSTRUCT;

-

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   png_uint_32 user_width_max PNG_DEPSTRUCT;

-   png_uint_32 user_height_max PNG_DEPSTRUCT;

-#endif

-

-/* New member added in libpng-1.0.25 and 1.2.17 */

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-   /* Storage for unknown chunk that the library doesn't recognize. */

-   png_unknown_chunk unknown_chunk PNG_DEPSTRUCT;

-#endif

-

-/* New members added in libpng-1.2.26 */

-  png_uint_32 old_big_row_buf_size PNG_DEPSTRUCT;

-  png_uint_32 old_prev_row_size PNG_DEPSTRUCT;

-

-/* New member added in libpng-1.2.30 */

-  png_charp chunkdata PNG_DEPSTRUCT;  /* buffer for reading chunk data */

-

-

-};

-

-

-/* This triggers a compiler error in png.c, if png.c and png.h

- * do not agree upon the version number.

- */

-typedef png_structp version_1_2_41;

-

-typedef png_struct FAR * FAR * png_structpp;

-

-/* Here are the function definitions most commonly used.  This is not

- * the place to find out how to use libpng.  See libpng.txt for the

- * full explanation, see example.c for the summary.  This just provides

- * a simple one line description of the use of each function.

- */

-

-/* Returns the version number of the library */

-extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void));

-

-/* Tell lib we have already handled the first <num_bytes> magic bytes.

- * Handling more than 8 bytes from the beginning of the file is an error.

- */

-extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr,

-   int num_bytes));

-

-/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a

- * PNG file.  Returns zero if the supplied bytes match the 8-byte PNG

- * signature, and non-zero otherwise.  Having num_to_check == 0 or

- * start > 7 will always fail (ie return non-zero).

- */

-extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,

-   png_size_t num_to_check));

-

-/* Simple signature checking function.  This is the same as calling

- * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).

- */

-extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)) PNG_DEPRECATED;

-

-/* Allocate and initialize png_ptr struct for reading, and any other memory. */

-extern PNG_EXPORT(png_structp,png_create_read_struct)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;

-

-/* Allocate and initialize png_ptr struct for writing, and any other memory */

-extern PNG_EXPORT(png_structp,png_create_write_struct)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;

-

-#ifdef PNG_WRITE_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size)

-   PNGARG((png_structp png_ptr));

-#endif

-

-#ifdef PNG_WRITE_SUPPORTED

-extern PNG_EXPORT(void,png_set_compression_buffer_size)

-   PNGARG((png_structp png_ptr, png_uint_32 size));

-#endif

-

-/* Reset the compression stream */

-extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr));

-

-/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */

-#ifdef PNG_USER_MEM_SUPPORTED

-extern PNG_EXPORT(png_structp,png_create_read_struct_2)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;

-extern PNG_EXPORT(png_structp,png_create_write_struct_2)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;

-#endif

-

-/* Write a PNG chunk - size, type, (optional) data, CRC. */

-extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,

-   png_bytep chunk_name, png_bytep data, png_size_t length));

-

-/* Write the start of a PNG chunk - length and chunk name. */

-extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr,

-   png_bytep chunk_name, png_uint_32 length));

-

-/* Write the data of a PNG chunk started with png_write_chunk_start(). */

-extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr,

-   png_bytep data, png_size_t length));

-

-/* Finish a chunk started with png_write_chunk_start() (includes CRC). */

-extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));

-

-/* Allocate and initialize the info structure */

-extern PNG_EXPORT(png_infop,png_create_info_struct)

-   PNGARG((png_structp png_ptr)) PNG_ALLOCATED;

-

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-/* Initialize the info structure (old interface - DEPRECATED) */

-extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr))

-    PNG_DEPRECATED;

-#undef png_info_init

-#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\

-    png_sizeof(png_info));

-#endif

-

-extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr,

-    png_size_t png_info_struct_size));

-

-/* Writes all the PNG information before the image. */

-extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read the information before the actual image data. */

-extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-#endif

-

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)

-   PNGARG((png_structp png_ptr, png_timep ptime));

-#endif

-

-#ifdef PNG_CONVERT_tIME_SUPPORTED

-/* Convert from a struct tm to png_time */

-extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,

-   struct tm FAR * ttime));

-

-/* Convert from time_t to png_time.  Uses gmtime() */

-extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime,

-   time_t ttime));

-#endif /* PNG_CONVERT_tIME_SUPPORTED */

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */

-extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr));

-#ifndef PNG_1_0_X

-extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp

-  png_ptr));

-#endif

-extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr));

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-/* Deprecated */

-extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp

-    png_ptr)) PNG_DEPRECATED;

-#endif

-#endif

-

-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

-/* Use blue, green, red order for pixels. */

-extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr));

-#endif

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-/* Expand the grayscale to 24-bit RGB if necessary. */

-extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr));

-#endif

-

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-/* Reduce RGB to grayscale. */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr,

-   int error_action, double red, double green ));

-#endif

-extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr,

-   int error_action, png_fixed_point red, png_fixed_point green ));

-extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp

-   png_ptr));

-#endif

-

-extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth,

-   png_colorp palette));

-

-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \

-    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

-extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \

-    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

-extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

-/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */

-extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr,

-   png_uint_32 filler, int flags));

-/* The values of the PNG_FILLER_ defines should NOT be changed */

-#define PNG_FILLER_BEFORE 0

-#define PNG_FILLER_AFTER 1

-/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */

-#ifndef PNG_1_0_X

-extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr,

-   png_uint_32 filler, int flags));

-#endif

-#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */

-

-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

-/* Swap bytes in 16-bit depth files. */

-extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)

-/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */

-extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)

-/* Swap packing order of pixels in bytes. */

-extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

-/* Converts files to legal bit depths. */

-extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr,

-   png_color_8p true_bits));

-#endif

-

-#if defined(PNG_READ_INTERLACING_SUPPORTED) || \

-    defined(PNG_WRITE_INTERLACING_SUPPORTED)

-/* Have the code handle the interlacing.  Returns the number of passes. */

-extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

-/* Invert monochrome files */

-extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr));

-#endif

-

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-/* Handle alpha and tRNS by replacing with a background color. */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,

-   png_color_16p background_color, int background_gamma_code,

-   int need_expand, double background_gamma));

-#endif

-#define PNG_BACKGROUND_GAMMA_UNKNOWN 0

-#define PNG_BACKGROUND_GAMMA_SCREEN  1

-#define PNG_BACKGROUND_GAMMA_FILE    2

-#define PNG_BACKGROUND_GAMMA_UNIQUE  3

-#endif

-

-#ifdef PNG_READ_16_TO_8_SUPPORTED

-/* Strip the second byte of information from a 16-bit depth file. */

-extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr));

-#endif

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-/* Turn on dithering, and reduce the palette to the number of colors available. */

-extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr,

-   png_colorp palette, int num_palette, int maximum_colors,

-   png_uint_16p histogram, int full_dither));

-#endif

-

-#ifdef PNG_READ_GAMMA_SUPPORTED

-/* Handle gamma correction. Screen_gamma=(display_exponent) */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr,

-   double screen_gamma, double default_file_gamma));

-#endif

-#endif

-

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \

-    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)

-/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */

-/* Deprecated and will be removed.  Use png_permit_mng_features() instead. */

-extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr,

-   int empty_plte_permitted)) PNG_DEPRECATED;

-#endif

-#endif

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-/* Set how many lines between output flushes - 0 for no flushing */

-extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows));

-/* Flush the current PNG output buffer */

-extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr));

-#endif

-

-/* Optional update palette with requested transformations */

-extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr));

-

-/* Optional call to update the users info structure */

-extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-

-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

-/* Read one or more rows of image data. */

-extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr,

-   png_bytepp row, png_bytepp display_row, png_uint_32 num_rows));

-#endif

-

-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

-/* Read a row of data. */

-extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr,

-   png_bytep row,

-   png_bytep display_row));

-#endif

-

-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

-/* Read the whole image into memory at once. */

-extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr,

-   png_bytepp image));

-#endif

-

-/* Write a row of image data */

-extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr,

-   png_bytep row));

-

-/* Write a few rows of image data */

-extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr,

-   png_bytepp row, png_uint_32 num_rows));

-

-/* Write the image data */

-extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr,

-   png_bytepp image));

-

-/* Writes the end of the PNG file. */

-extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-

-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

-/* Read the end of the PNG file. */

-extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-#endif

-

-/* Free any memory associated with the png_info_struct */

-extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr,

-   png_infopp info_ptr_ptr));

-

-/* Free any memory associated with the png_struct and the png_info_structs */

-extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp

-   png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));

-

-/* Free all memory used by the read (old method - NOT DLL EXPORTED) */

-extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_infop end_info_ptr)) PNG_DEPRECATED;

-

-/* Free any memory associated with the png_struct and the png_info_structs */

-extern PNG_EXPORT(void,png_destroy_write_struct)

-   PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));

-

-/* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */

-extern void png_write_destroy PNGARG((png_structp png_ptr)) PNG_DEPRECATED;

-

-/* Set the libpng method of handling chunk CRC errors */

-extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,

-   int crit_action, int ancil_action));

-

-/* Values for png_set_crc_action() to say how to handle CRC errors in

- * ancillary and critical chunks, and whether to use the data contained

- * therein.  Note that it is impossible to "discard" data in a critical

- * chunk.  For versions prior to 0.90, the action was always error/quit,

- * whereas in version 0.90 and later, the action for CRC errors in ancillary

- * chunks is warn/discard.  These values should NOT be changed.

- *

- *      value                       action:critical     action:ancillary

- */

-#define PNG_CRC_DEFAULT       0  /* error/quit          warn/discard data */

-#define PNG_CRC_ERROR_QUIT    1  /* error/quit          error/quit        */

-#define PNG_CRC_WARN_DISCARD  2  /* (INVALID)           warn/discard data */

-#define PNG_CRC_WARN_USE      3  /* warn/use data       warn/use data     */

-#define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */

-#define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */

-

-/* These functions give the user control over the scan-line filtering in

- * libpng and the compression methods used by zlib.  These functions are

- * mainly useful for testing, as the defaults should work with most users.

- * Those users who are tight on memory or want faster performance at the

- * expense of compression can modify them.  See the compression library

- * header file (zlib.h) for an explination of the compression functions.

- */

-

-/* Set the filtering method(s) used by libpng.  Currently, the only valid

- * value for "method" is 0.

- */

-extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,

-   int filters));

-

-/* Flags for png_set_filter() to say which filters to use.  The flags

- * are chosen so that they don't conflict with real filter types

- * below, in case they are supplied instead of the #defined constants.

- * These values should NOT be changed.

- */

-#define PNG_NO_FILTERS     0x00

-#define PNG_FILTER_NONE    0x08

-#define PNG_FILTER_SUB     0x10

-#define PNG_FILTER_UP      0x20

-#define PNG_FILTER_AVG     0x40

-#define PNG_FILTER_PAETH   0x80

-#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \

-                         PNG_FILTER_AVG | PNG_FILTER_PAETH)

-

-/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.

- * These defines should NOT be changed.

- */

-#define PNG_FILTER_VALUE_NONE  0

-#define PNG_FILTER_VALUE_SUB   1

-#define PNG_FILTER_VALUE_UP    2

-#define PNG_FILTER_VALUE_AVG   3

-#define PNG_FILTER_VALUE_PAETH 4

-#define PNG_FILTER_VALUE_LAST  5

-

-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */

-/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_

- * defines, either the default (minimum-sum-of-absolute-differences), or

- * the experimental method (weighted-minimum-sum-of-absolute-differences).

- *

- * Weights are factors >= 1.0, indicating how important it is to keep the

- * filter type consistent between rows.  Larger numbers mean the current

- * filter is that many times as likely to be the same as the "num_weights"

- * previous filters.  This is cumulative for each previous row with a weight.

- * There needs to be "num_weights" values in "filter_weights", or it can be

- * NULL if the weights aren't being specified.  Weights have no influence on

- * the selection of the first row filter.  Well chosen weights can (in theory)

- * improve the compression for a given image.

- *

- * Costs are factors >= 1.0 indicating the relative decoding costs of a

- * filter type.  Higher costs indicate more decoding expense, and are

- * therefore less likely to be selected over a filter with lower computational

- * costs.  There needs to be a value in "filter_costs" for each valid filter

- * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't

- * setting the costs.  Costs try to improve the speed of decompression without

- * unduly increasing the compressed image size.

- *

- * A negative weight or cost indicates the default value is to be used, and

- * values in the range [0.0, 1.0) indicate the value is to remain unchanged.

- * The default values for both weights and costs are currently 1.0, but may

- * change if good general weighting/cost heuristics can be found.  If both

- * the weights and costs are set to 1.0, this degenerates the WEIGHTED method

- * to the UNWEIGHTED method, but with added encoding time/computation.

- */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr,

-   int heuristic_method, int num_weights, png_doublep filter_weights,

-   png_doublep filter_costs));

-#endif

-#endif /*  PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */

-

-/* Heuristic used for row filter selection.  These defines should NOT be

- * changed.

- */

-#define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */

-#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */

-#define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */

-#define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */

-

-/* Set the library compression level.  Currently, valid values range from

- * 0 - 9, corresponding directly to the zlib compression levels 0 - 9

- * (0 - no compression, 9 - "maximal" compression).  Note that tests have

- * shown that zlib compression levels 3-6 usually perform as well as level 9

- * for PNG images, and do considerably fewer caclulations.  In the future,

- * these values may not correspond directly to the zlib compression levels.

- */

-extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr,

-   int level));

-

-extern PNG_EXPORT(void,png_set_compression_mem_level)

-   PNGARG((png_structp png_ptr, int mem_level));

-

-extern PNG_EXPORT(void,png_set_compression_strategy)

-   PNGARG((png_structp png_ptr, int strategy));

-

-extern PNG_EXPORT(void,png_set_compression_window_bits)

-   PNGARG((png_structp png_ptr, int window_bits));

-

-extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,

-   int method));

-

-/* These next functions are called for input/output, memory, and error

- * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,

- * and call standard C I/O routines such as fread(), fwrite(), and

- * fprintf().  These functions can be made to use other I/O routines

- * at run time for those applications that need to handle I/O in a

- * different manner by calling png_set_???_fn().  See libpng.txt for

- * more information.

- */

-

-#ifdef PNG_STDIO_SUPPORTED

-/* Initialize the input/output for the PNG file to the default functions. */

-extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp));

-#endif

-

-/* Replace the (error and abort), and warning functions with user

- * supplied functions.  If no messages are to be printed you must still

- * write and use replacement functions. The replacement error_fn should

- * still do a longjmp to the last setjmp location if you are using this

- * method of error handling.  If error_fn or warning_fn is NULL, the

- * default function will be used.

- */

-

-extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr,

-   png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));

-

-/* Return the user pointer associated with the error functions */

-extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));

-

-/* Replace the default data output functions with a user supplied one(s).

- * If buffered output is not used, then output_flush_fn can be set to NULL.

- * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time

- * output_flush_fn will be ignored (and thus can be NULL).

- * It is probably a mistake to use NULL for output_flush_fn if

- * write_data_fn is not also NULL unless you have built libpng with

- * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's

- * default flush function, which uses the standard *FILE structure, will

- * be used.

- */

-extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,

-   png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));

-

-/* Replace the default data input function with a user supplied one. */

-extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,

-   png_voidp io_ptr, png_rw_ptr read_data_fn));

-

-/* Return the user pointer associated with the I/O functions */

-extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));

-

-extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,

-   png_read_status_ptr read_row_fn));

-

-extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,

-   png_write_status_ptr write_row_fn));

-

-#ifdef PNG_USER_MEM_SUPPORTED

-/* Replace the default memory allocation functions with user supplied one(s). */

-extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,

-   png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));

-/* Return the user pointer associated with the memory functions */

-extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));

-#endif

-

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_LEGACY_SUPPORTED)

-extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp

-   png_ptr, png_user_transform_ptr read_user_transform_fn));

-#endif

-

-#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_LEGACY_SUPPORTED)

-extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp

-   png_ptr, png_user_transform_ptr write_user_transform_fn));

-#endif

-

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_LEGACY_SUPPORTED)

-extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp

-   png_ptr, png_voidp user_transform_ptr, int user_transform_depth,

-   int user_transform_channels));

-/* Return the user pointer associated with the user transform functions */

-extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr)

-   PNGARG((png_structp png_ptr));

-#endif

-

-#ifdef PNG_USER_CHUNKS_SUPPORTED

-extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,

-   png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));

-extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp

-   png_ptr));

-#endif

-

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-/* Sets the function callbacks for the push reader, and a pointer to a

- * user-defined structure available to the callback functions.

- */

-extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr,

-   png_voidp progressive_ptr,

-   png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,

-   png_progressive_end_ptr end_fn));

-

-/* Returns the user pointer associated with the push read functions */

-extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)

-   PNGARG((png_structp png_ptr));

-

-/* Function to be called when data becomes available */

-extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));

-

-/* Function that combines rows.  Not very much different than the

- * png_combine_row() call.  Is this even used?????

- */

-extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,

-   png_bytep old_row, png_bytep new_row));

-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

-

-extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,

-   png_uint_32 size)) PNG_ALLOCATED;

-

-#ifdef PNG_1_0_X

-#  define png_malloc_warn png_malloc

-#else

-/* Added at libpng version 1.2.4 */

-extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr,

-   png_uint_32 size)) PNG_ALLOCATED;

-#endif

-

-/* Frees a pointer allocated by png_malloc() */

-extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));

-

-#ifdef PNG_1_0_X

-/* Function to allocate memory for zlib. */

-extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items,

-   uInt size));

-

-/* Function to free memory for zlib */

-extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr));

-#endif

-

-/* Free data that was allocated internally */

-extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 free_me, int num));

-#ifdef PNG_FREE_ME_SUPPORTED

-/* Reassign responsibility for freeing existing data, whether allocated

- * by libpng or by the application

- */

-extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int freer, png_uint_32 mask));

-#endif

-/* Assignments for png_data_freer */

-#define PNG_DESTROY_WILL_FREE_DATA 1

-#define PNG_SET_WILL_FREE_DATA 1

-#define PNG_USER_WILL_FREE_DATA 2

-/* Flags for png_ptr->free_me and info_ptr->free_me */

-#define PNG_FREE_HIST 0x0008

-#define PNG_FREE_ICCP 0x0010

-#define PNG_FREE_SPLT 0x0020

-#define PNG_FREE_ROWS 0x0040

-#define PNG_FREE_PCAL 0x0080

-#define PNG_FREE_SCAL 0x0100

-#define PNG_FREE_UNKN 0x0200

-#define PNG_FREE_LIST 0x0400

-#define PNG_FREE_PLTE 0x1000

-#define PNG_FREE_TRNS 0x2000

-#define PNG_FREE_TEXT 0x4000

-#define PNG_FREE_ALL  0x7fff

-#define PNG_FREE_MUL  0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */

-

-#ifdef PNG_USER_MEM_SUPPORTED

-extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,

-   png_uint_32 size)) PNG_ALLOCATED;

-extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,

-   png_voidp ptr));

-#endif

-

-extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr,

-   png_voidp s1, png_voidp s2, png_uint_32 size));

-

-extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr,

-   png_voidp s1, int value, png_uint_32 size));

-

-#if defined(USE_FAR_KEYWORD)  /* memory model conversion function */

-extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,

-   int check));

-#endif /* USE_FAR_KEYWORD */

-

-#ifndef PNG_NO_ERROR_TEXT

-/* Fatal error in PNG image of libpng - can't continue */

-extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,

-   png_const_charp error_message)) PNG_NORETURN;

-

-/* The same, but the chunk name is prepended to the error string. */

-extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,

-   png_const_charp error_message)) PNG_NORETURN;

-#else

-/* Fatal error in PNG image of libpng - can't continue */

-extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr)) PNG_NORETURN;

-#endif

-

-#ifndef PNG_NO_WARNINGS

-/* Non-fatal error in libpng.  Can continue, but may have a problem. */

-extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,

-   png_const_charp warning_message));

-

-#ifdef PNG_READ_SUPPORTED

-/* Non-fatal error in libpng, chunk name is prepended to message. */

-extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,

-   png_const_charp warning_message));

-#endif /* PNG_READ_SUPPORTED */

-#endif /* PNG_NO_WARNINGS */

-

-/* The png_set_<chunk> functions are for storing values in the png_info_struct.

- * Similarly, the png_get_<chunk> calls are used to read values from the

- * png_info_struct, either storing the parameters in the passed variables, or

- * setting pointers into the png_info_struct where the data is stored.  The

- * png_get_<chunk> functions return a non-zero value if the data was available

- * in info_ptr, or return zero and do not change any of the parameters if the

- * data was not available.

- *

- * These functions should be used instead of directly accessing png_info

- * to avoid problems with future changes in the size and internal layout of

- * png_info_struct.

- */

-/* Returns "flag" if chunk data is valid in info_ptr. */

-extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,

-png_infop info_ptr, png_uint_32 flag));

-

-/* Returns number of bytes needed to hold a transformed row. */

-extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-/* Returns row_pointers, which is an array of pointers to scanlines that was

- * returned from png_read_png().

- */

-extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-/* Set row_pointers, which is an array of pointers to scanlines for use

- * by png_write_png().

- */

-extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytepp row_pointers));

-#endif

-

-/* Returns number of color channels in image. */

-extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-#ifdef PNG_EASY_ACCESS_SUPPORTED

-/* Returns image width in pixels. */

-extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image height in pixels. */

-extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image bit_depth. */

-extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image color_type. */

-extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image filter_type. */

-extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image interlace_type. */

-extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image compression_type. */

-extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image resolution in pixels per meter, from pHYs chunk data. */

-extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns pixel aspect ratio, computed from pHYs chunk data.  */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-#endif

-

-/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */

-extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-#endif /* PNG_EASY_ACCESS_SUPPORTED */

-

-/* Returns pointer to signature string read from PNG header */

-extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-#ifdef PNG_bKGD_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_16p *background));

-#endif

-

-#ifdef PNG_bKGD_SUPPORTED

-extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_16p background));

-#endif

-

-#ifdef PNG_cHRM_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double *white_x, double *white_y, double *red_x,

-   double *red_y, double *green_x, double *green_y, double *blue_x,

-   double *blue_y));

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point

-   *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,

-   png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point

-   *int_blue_x, png_fixed_point *int_blue_y));

-#endif

-#endif

-

-#ifdef PNG_cHRM_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double white_x, double white_y, double red_x,

-   double red_y, double green_x, double green_y, double blue_x, double blue_y));

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,

-   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

-   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

-   png_fixed_point int_blue_y));

-#endif

-#endif

-

-#ifdef PNG_gAMA_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double *file_gamma));

-#endif

-extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point *int_file_gamma));

-#endif

-

-#ifdef PNG_gAMA_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double file_gamma));

-#endif

-extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point int_file_gamma));

-#endif

-

-#ifdef PNG_hIST_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_16p *hist));

-#endif

-

-#ifdef PNG_hIST_SUPPORTED

-extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_16p hist));

-#endif

-

-extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,

-   int *bit_depth, int *color_type, int *interlace_method,

-   int *compression_method, int *filter_method));

-

-extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_method, int compression_method,

-   int filter_method));

-

-#ifdef PNG_oFFs_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,

-   int *unit_type));

-#endif

-

-#ifdef PNG_oFFs_SUPPORTED

-extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,

-   int unit_type));

-#endif

-

-#ifdef PNG_pCAL_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,

-   int *type, int *nparams, png_charp *units, png_charpp *params));

-#endif

-

-#ifdef PNG_pCAL_SUPPORTED

-extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,

-   int type, int nparams, png_charp units, png_charpp params));

-#endif

-

-#ifdef PNG_pHYs_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));

-#endif

-

-#ifdef PNG_pHYs_SUPPORTED

-extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));

-#endif

-

-extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_colorp *palette, int *num_palette));

-

-extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_colorp palette, int num_palette));

-

-#ifdef PNG_sBIT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_8p *sig_bit));

-#endif

-

-#ifdef PNG_sBIT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_8p sig_bit));

-#endif

-

-#ifdef PNG_sRGB_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int *intent));

-#endif

-

-#ifdef PNG_sRGB_SUPPORTED

-extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int intent));

-extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int intent));

-#endif

-

-#ifdef PNG_iCCP_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charpp name, int *compression_type,

-   png_charpp profile, png_uint_32 *proflen));

-   /* Note to maintainer: profile should be png_bytepp */

-#endif

-

-#ifdef PNG_iCCP_SUPPORTED

-extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charp name, int compression_type,

-   png_charp profile, png_uint_32 proflen));

-   /* Note to maintainer: profile should be png_bytep */

-#endif

-

-#ifdef PNG_sPLT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_sPLT_tpp entries));

-#endif

-

-#ifdef PNG_sPLT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_sPLT_tp entries, int nentries));

-#endif

-

-#ifdef PNG_TEXT_SUPPORTED

-/* png_get_text also returns the number of text chunks in *num_text */

-extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_textp *text_ptr, int *num_text));

-#endif

-

-/*

- *  Note while png_set_text() will accept a structure whose text,

- *  language, and  translated keywords are NULL pointers, the structure

- *  returned by png_get_text will always contain regular

- *  zero-terminated C strings.  They might be empty strings but

- *  they will never be NULL pointers.

- */

-

-#ifdef PNG_TEXT_SUPPORTED

-extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_textp text_ptr, int num_text));

-#endif

-

-#ifdef PNG_tIME_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_timep *mod_time));

-#endif

-

-#ifdef PNG_tIME_SUPPORTED

-extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_timep mod_time));

-#endif

-

-#ifdef PNG_tRNS_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytep *trans, int *num_trans,

-   png_color_16p *trans_values));

-#endif

-

-#ifdef PNG_tRNS_SUPPORTED

-extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytep trans, int num_trans,

-   png_color_16p trans_values));

-#endif

-

-#ifdef PNG_tRNS_SUPPORTED

-#endif

-

-#ifdef PNG_sCAL_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int *unit, double *width, double *height));

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));

-#endif

-#endif

-#endif /* PNG_sCAL_SUPPORTED */

-

-#ifdef PNG_sCAL_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int unit, double width, double height));

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));

-#endif

-#endif

-#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */

-

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-/* Provide a list of chunks and how they are to be handled, if the built-in

-   handling or default unknown chunk handling is not desired.  Any chunks not

-   listed will be handled in the default manner.  The IHDR and IEND chunks

-   must not be listed.

-      keep = 0: follow default behaviour

-           = 1: do not keep

-           = 2: keep only if safe-to-copy

-           = 3: keep even if unsafe-to-copy

-*/

-extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp

-   png_ptr, int keep, png_bytep chunk_list, int num_chunks));

-PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep

-   chunk_name));

-#endif

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));

-extern PNG_EXPORT(void, png_set_unknown_chunk_location)

-   PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));

-extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp

-   png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));

-#endif

-

-/* Png_free_data() will turn off the "valid" flag for anything it frees.

- * If you need to turn it off for a chunk that your application has freed,

- * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);

- */

-extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int mask));

-

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-/* The "params" pointer is currently not used and is for future expansion. */

-extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,

-                        png_infop info_ptr,

-                        int transforms,

-                        png_voidp params));

-extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,

-                        png_infop info_ptr,

-                        int transforms,

-                        png_voidp params));

-#endif

-

-/* Define PNG_DEBUG at compile time for debugging information.  Higher

- * numbers for PNG_DEBUG mean more debugging information.  This has

- * only been added since version 0.95 so it is not implemented throughout

- * libpng yet, but more support will be added as needed.

- */

-#ifdef PNG_DEBUG

-#if (PNG_DEBUG > 0)

-#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)

-#include <crtdbg.h>

-#if (PNG_DEBUG > 1)

-#ifndef _DEBUG

-#  define _DEBUG

-#endif

-#ifndef png_debug

-#define png_debug(l,m)  _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE)

-#endif

-#ifndef png_debug1

-#define png_debug1(l,m,p1)  _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1)

-#endif

-#ifndef png_debug2

-#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2)

-#endif

-#endif

-#else /* PNG_DEBUG_FILE || !_MSC_VER */

-#ifndef PNG_DEBUG_FILE

-#define PNG_DEBUG_FILE stderr

-#endif /* PNG_DEBUG_FILE */

-

-#if (PNG_DEBUG > 1)

-/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on non-ISO

- * compilers.

- */

-#  ifdef __STDC__

-#    ifndef png_debug

-#      define png_debug(l,m) \

-       { \

-       int num_tabs=l; \

-       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \

-         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \

-       }

-#    endif

-#    ifndef png_debug1

-#      define png_debug1(l,m,p1) \

-       { \

-       int num_tabs=l; \

-       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \

-         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \

-       }

-#    endif

-#    ifndef png_debug2

-#      define png_debug2(l,m,p1,p2) \

-       { \

-       int num_tabs=l; \

-       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \

-         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \

-       }

-#    endif

-#  else /* __STDC __ */

-#    ifndef png_debug

-#      define png_debug(l,m) \

-       { \

-       int num_tabs=l; \

-       char format[256]; \

-       snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \

-         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \

-         m,PNG_STRING_NEWLINE); \

-       fprintf(PNG_DEBUG_FILE,format); \

-       }

-#    endif

-#    ifndef png_debug1

-#      define png_debug1(l,m,p1) \

-       { \

-       int num_tabs=l; \

-       char format[256]; \

-       snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \

-         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \

-         m,PNG_STRING_NEWLINE); \

-       fprintf(PNG_DEBUG_FILE,format,p1); \

-       }

-#    endif

-#    ifndef png_debug2

-#      define png_debug2(l,m,p1,p2) \

-       { \

-       int num_tabs=l; \

-       char format[256]; \

-       snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \

-         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \

-         m,PNG_STRING_NEWLINE); \

-       fprintf(PNG_DEBUG_FILE,format,p1,p2); \

-       }

-#    endif

-#  endif /* __STDC __ */

-#endif /* (PNG_DEBUG > 1) */

-

-#endif /* _MSC_VER */

-#endif /* (PNG_DEBUG > 0) */

-#endif /* PNG_DEBUG */

-#ifndef png_debug

-#define png_debug(l, m)

-#endif

-#ifndef png_debug1

-#define png_debug1(l, m, p1)

-#endif

-#ifndef png_debug2

-#define png_debug2(l, m, p1, p2)

-#endif

-

-extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp

-   png_ptr, png_uint_32 mng_features_permitted));

-#endif

-

-/* For use in png_set_keep_unknown, added to version 1.2.6 */

-#define PNG_HANDLE_CHUNK_AS_DEFAULT   0

-#define PNG_HANDLE_CHUNK_NEVER        1

-#define PNG_HANDLE_CHUNK_IF_SAFE      2

-#define PNG_HANDLE_CHUNK_ALWAYS       3

-

-/* Added to version 1.2.0 */

-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

-#ifdef PNG_MMX_CODE_SUPPORTED

-#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED  0x01  /* not user-settable */

-#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU    0x02  /* not user-settable */

-#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  0x04

-#define PNG_ASM_FLAG_MMX_READ_INTERLACE    0x08

-#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB   0x10

-#define PNG_ASM_FLAG_MMX_READ_FILTER_UP    0x20

-#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG   0x40

-#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80

-#define PNG_ASM_FLAGS_INITIALIZED          0x80000000  /* not user-settable */

-

-#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \

-                           | PNG_ASM_FLAG_MMX_READ_INTERLACE    \

-                           | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \

-                           | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \

-                           | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \

-                           | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH )

-#define PNG_MMX_WRITE_FLAGS ( 0 )

-

-#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \

-                      | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU   \

-                      | PNG_MMX_READ_FLAGS                \

-                      | PNG_MMX_WRITE_FLAGS )

-

-#define PNG_SELECT_READ   1

-#define PNG_SELECT_WRITE  2

-#endif /* PNG_MMX_CODE_SUPPORTED */

-

-#ifndef PNG_1_0_X

-/* pngget.c */

-extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask)

-   PNGARG((int flag_select, int *compilerID));

-

-/* pngget.c */

-extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask)

-   PNGARG((int flag_select));

-

-/* pngget.c */

-extern PNG_EXPORT(png_uint_32,png_get_asm_flags)

-   PNGARG((png_structp png_ptr));

-

-/* pngget.c */

-extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold)

-   PNGARG((png_structp png_ptr));

-

-/* pngget.c */

-extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold)

-   PNGARG((png_structp png_ptr));

-

-/* pngset.c */

-extern PNG_EXPORT(void,png_set_asm_flags)

-   PNGARG((png_structp png_ptr, png_uint_32 asm_flags));

-

-/* pngset.c */

-extern PNG_EXPORT(void,png_set_mmx_thresholds)

-   PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold,

-   png_uint_32 mmx_rowbytes_threshold));

-

-#endif /* PNG_1_0_X */

-

-#ifndef PNG_1_0_X

-/* png.c, pnggccrd.c, or pngvcrd.c */

-extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));

-#endif /* PNG_1_0_X */

-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

-

-/* Strip the prepended error numbers ("#nnn ") from error and warning

- * messages before passing them to the error or warning handler.

- */

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp

-   png_ptr, png_uint_32 strip_mode));

-#endif

-

-/* Added at libpng-1.2.6 */

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp

-   png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));

-extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp

-   png_ptr));

-extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp

-   png_ptr));

-#endif

-/* Maintainer: Put new public prototypes here ^, in libpng.3, and in

- * project defs

- */

-

-#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED

-/* With these routines we avoid an integer divide, which will be slower on

- * most machines.  However, it does take more operations than the corresponding

- * divide method, so it may be slower on a few RISC systems.  There are two

- * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.

- *

- * Note that the rounding factors are NOT supposed to be the same!  128 and

- * 32768 are correct for the NODIV code; 127 and 32767 are correct for the

- * standard method.

- *

- * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]

- */

-

- /* fg and bg should be in `gamma 1.0' space; alpha is the opacity          */

-

-#  define png_composite(composite, fg, alpha, bg)                            \

-     { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \

-                        +        (png_uint_16)(bg)*(png_uint_16)(255 -       \

-                        (png_uint_16)(alpha)) + (png_uint_16)128);           \

-       (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }

-

-#  define png_composite_16(composite, fg, alpha, bg)                         \

-     { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \

-                        + (png_uint_32)(bg)*(png_uint_32)(65535L -           \

-                        (png_uint_32)(alpha)) + (png_uint_32)32768L);        \

-       (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }

-

-#else  /* Standard method using integer division */

-

-#  define png_composite(composite, fg, alpha, bg)                            \

-     (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) +    \

-       (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) +       \

-       (png_uint_16)127) / 255)

-

-#  define png_composite_16(composite, fg, alpha, bg)                         \

-     (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \

-       (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) +      \

-       (png_uint_32)32767) / (png_uint_32)65535L)

-

-#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */

-

-/* Inline macros to do direct reads of bytes from the input buffer.  These

- * require that you are using an architecture that uses PNG byte ordering

- * (MSB first) and supports unaligned data storage.  I think that PowerPC

- * in big-endian mode and 680x0 are the only ones that will support this.

- * The x86 line of processors definitely do not.  The png_get_int_32()

- * routine also assumes we are using two's complement format for negative

- * values, which is almost certainly true.

- */

-#ifdef PNG_READ_BIG_ENDIAN_SUPPORTED

-#  define png_get_uint_32(buf) ( *((png_uint_32p) (buf)))

-#  define png_get_uint_16(buf) ( *((png_uint_16p) (buf)))

-#  define png_get_int_32(buf)  ( *((png_int_32p)  (buf)))

-#else

-extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf));

-extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf));

-extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf));

-#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */

-extern PNG_EXPORT(png_uint_32,png_get_uint_31)

-  PNGARG((png_structp png_ptr, png_bytep buf));

-/* No png_get_int_16 -- may be added if there's a real need for it. */

-

-/* Place a 32-bit number into a buffer in PNG byte order (big-endian).

- */

-extern PNG_EXPORT(void,png_save_uint_32)

-   PNGARG((png_bytep buf, png_uint_32 i));

-extern PNG_EXPORT(void,png_save_int_32)

-   PNGARG((png_bytep buf, png_int_32 i));

-

-/* Place a 16-bit number into a buffer in PNG byte order.

- * The parameter is declared unsigned int, not png_uint_16,

- * just to avoid potential problems on pre-ANSI C compilers.

- */

-extern PNG_EXPORT(void,png_save_uint_16)

-   PNGARG((png_bytep buf, unsigned int i));

-/* No png_save_int_16 -- may be added if there's a real need for it. */

-

-/* ************************************************************************* */

-

-/* These next functions are used internally in the code.  They generally

- * shouldn't be used unless you are writing code to add or replace some

- * functionality in libpng.  More information about most functions can

- * be found in the files where the functions are located.

- */

-

-

-/* Various modes of operation, that are visible to applications because

- * they are used for unknown chunk location.

- */

-#define PNG_HAVE_IHDR               0x01

-#define PNG_HAVE_PLTE               0x02

-#define PNG_HAVE_IDAT               0x04

-#define PNG_AFTER_IDAT              0x08 /* Have complete zlib datastream */

-#define PNG_HAVE_IEND               0x10

-

-#ifdef PNG_INTERNAL

-

-/* More modes of operation.  Note that after an init, mode is set to

- * zero automatically when the structure is created.

- */

-#define PNG_HAVE_gAMA               0x20

-#define PNG_HAVE_cHRM               0x40

-#define PNG_HAVE_sRGB               0x80

-#define PNG_HAVE_CHUNK_HEADER      0x100

-#define PNG_WROTE_tIME             0x200

-#define PNG_WROTE_INFO_BEFORE_PLTE 0x400

-#define PNG_BACKGROUND_IS_GRAY     0x800

-#define PNG_HAVE_PNG_SIGNATURE    0x1000

-#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */

-

-/* Flags for the transformations the PNG library does on the image data */

-#define PNG_BGR                0x0001

-#define PNG_INTERLACE          0x0002

-#define PNG_PACK               0x0004

-#define PNG_SHIFT              0x0008

-#define PNG_SWAP_BYTES         0x0010

-#define PNG_INVERT_MONO        0x0020

-#define PNG_DITHER             0x0040

-#define PNG_BACKGROUND         0x0080

-#define PNG_BACKGROUND_EXPAND  0x0100

-                          /*   0x0200 unused */

-#define PNG_16_TO_8            0x0400

-#define PNG_RGBA               0x0800

-#define PNG_EXPAND             0x1000

-#define PNG_GAMMA              0x2000

-#define PNG_GRAY_TO_RGB        0x4000

-#define PNG_FILLER             0x8000L

-#define PNG_PACKSWAP          0x10000L

-#define PNG_SWAP_ALPHA        0x20000L

-#define PNG_STRIP_ALPHA       0x40000L

-#define PNG_INVERT_ALPHA      0x80000L

-#define PNG_USER_TRANSFORM   0x100000L

-#define PNG_RGB_TO_GRAY_ERR  0x200000L

-#define PNG_RGB_TO_GRAY_WARN 0x400000L

-#define PNG_RGB_TO_GRAY      0x600000L  /* two bits, RGB_TO_GRAY_ERR|WARN */

-                       /*    0x800000L     Unused */

-#define PNG_ADD_ALPHA       0x1000000L  /* Added to libpng-1.2.7 */

-#define PNG_EXPAND_tRNS     0x2000000L  /* Added to libpng-1.2.9 */

-#define PNG_PREMULTIPLY_ALPHA 0x4000000L  /* Added to libpng-1.2.41 */

-                                          /* by volker */

-                       /*   0x8000000L  unused */

-                       /*  0x10000000L  unused */

-                       /*  0x20000000L  unused */

-                       /*  0x40000000L  unused */

-

-/* Flags for png_create_struct */

-#define PNG_STRUCT_PNG   0x0001

-#define PNG_STRUCT_INFO  0x0002

-

-/* Scaling factor for filter heuristic weighting calculations */

-#define PNG_WEIGHT_SHIFT 8

-#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))

-#define PNG_COST_SHIFT 3

-#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))

-

-/* Flags for the png_ptr->flags rather than declaring a byte for each one */

-#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0001

-#define PNG_FLAG_ZLIB_CUSTOM_LEVEL        0x0002

-#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL    0x0004

-#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS  0x0008

-#define PNG_FLAG_ZLIB_CUSTOM_METHOD       0x0010

-#define PNG_FLAG_ZLIB_FINISHED            0x0020

-#define PNG_FLAG_ROW_INIT                 0x0040

-#define PNG_FLAG_FILLER_AFTER             0x0080

-#define PNG_FLAG_CRC_ANCILLARY_USE        0x0100

-#define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200

-#define PNG_FLAG_CRC_CRITICAL_USE         0x0400

-#define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800

-#define PNG_FLAG_FREE_PLTE                0x1000

-#define PNG_FLAG_FREE_TRNS                0x2000

-#define PNG_FLAG_FREE_HIST                0x4000

-#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000L

-#define PNG_FLAG_KEEP_UNSAFE_CHUNKS       0x10000L

-#define PNG_FLAG_LIBRARY_MISMATCH         0x20000L

-#define PNG_FLAG_STRIP_ERROR_NUMBERS      0x40000L

-#define PNG_FLAG_STRIP_ERROR_TEXT         0x80000L

-#define PNG_FLAG_MALLOC_NULL_MEM_OK       0x100000L

-#define PNG_FLAG_ADD_ALPHA                0x200000L  /* Added to libpng-1.2.8 */

-#define PNG_FLAG_STRIP_ALPHA              0x400000L  /* Added to libpng-1.2.8 */

-                                  /*      0x800000L  unused */

-                                  /*     0x1000000L  unused */

-                                  /*     0x2000000L  unused */

-                                  /*     0x4000000L  unused */

-                                  /*     0x8000000L  unused */

-                                  /*    0x10000000L  unused */

-                                  /*    0x20000000L  unused */

-                                  /*    0x40000000L  unused */

-

-#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \

-                                     PNG_FLAG_CRC_ANCILLARY_NOWARN)

-

-#define PNG_FLAG_CRC_CRITICAL_MASK  (PNG_FLAG_CRC_CRITICAL_USE | \

-                                     PNG_FLAG_CRC_CRITICAL_IGNORE)

-

-#define PNG_FLAG_CRC_MASK           (PNG_FLAG_CRC_ANCILLARY_MASK | \

-                                     PNG_FLAG_CRC_CRITICAL_MASK)

-

-/* Save typing and make code easier to understand */

-

-#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \

-   abs((int)((c1).green) - (int)((c2).green)) + \

-   abs((int)((c1).blue) - (int)((c2).blue)))

-

-/* Added to libpng-1.2.6 JB */

-#define PNG_ROWBYTES(pixel_bits, width) \

-    ((pixel_bits) >= 8 ? \

-    ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \

-    (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) )

-

-/* PNG_OUT_OF_RANGE returns true if value is outside the range

- * ideal-delta..ideal+delta.  Each argument is evaluated twice.

- * "ideal" and "delta" should be constants, normally simple

- * integers, "value" a variable. Added to libpng-1.2.6 JB

- */

-#define PNG_OUT_OF_RANGE(value, ideal, delta) \

-        ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )

-

-/* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */

-#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)

-/* Place to hold the signature string for a PNG file. */

-#ifdef PNG_USE_GLOBAL_ARRAYS

-   PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8];

-#else

-#endif

-#endif /* PNG_NO_EXTERN */

-

-/* Constant strings for known chunk types.  If you need to add a chunk,

- * define the name here, and add an invocation of the macro in png.c and

- * wherever it's needed.

- */

-#define PNG_IHDR png_byte png_IHDR[5] = { 73,  72,  68,  82, '\0'}

-#define PNG_IDAT png_byte png_IDAT[5] = { 73,  68,  65,  84, '\0'}

-#define PNG_IEND png_byte png_IEND[5] = { 73,  69,  78,  68, '\0'}

-#define PNG_PLTE png_byte png_PLTE[5] = { 80,  76,  84,  69, '\0'}

-#define PNG_bKGD png_byte png_bKGD[5] = { 98,  75,  71,  68, '\0'}

-#define PNG_cHRM png_byte png_cHRM[5] = { 99,  72,  82,  77, '\0'}

-#define PNG_gAMA png_byte png_gAMA[5] = {103,  65,  77,  65, '\0'}

-#define PNG_hIST png_byte png_hIST[5] = {104,  73,  83,  84, '\0'}

-#define PNG_iCCP png_byte png_iCCP[5] = {105,  67,  67,  80, '\0'}

-#define PNG_iTXt png_byte png_iTXt[5] = {105,  84,  88, 116, '\0'}

-#define PNG_oFFs png_byte png_oFFs[5] = {111,  70,  70, 115, '\0'}

-#define PNG_pCAL png_byte png_pCAL[5] = {112,  67,  65,  76, '\0'}

-#define PNG_sCAL png_byte png_sCAL[5] = {115,  67,  65,  76, '\0'}

-#define PNG_pHYs png_byte png_pHYs[5] = {112,  72,  89, 115, '\0'}

-#define PNG_sBIT png_byte png_sBIT[5] = {115,  66,  73,  84, '\0'}

-#define PNG_sPLT png_byte png_sPLT[5] = {115,  80,  76,  84, '\0'}

-#define PNG_sRGB png_byte png_sRGB[5] = {115,  82,  71,  66, '\0'}

-#define PNG_tEXt png_byte png_tEXt[5] = {116,  69,  88, 116, '\0'}

-#define PNG_tIME png_byte png_tIME[5] = {116,  73,  77,  69, '\0'}

-#define PNG_tRNS png_byte png_tRNS[5] = {116,  82,  78,  83, '\0'}

-#define PNG_zTXt png_byte png_zTXt[5] = {122,  84,  88, 116, '\0'}

-

-#ifdef PNG_USE_GLOBAL_ARRAYS

-PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5];

-PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5];

-#endif /* PNG_USE_GLOBAL_ARRAYS */

-

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-/* Initialize png_ptr struct for reading, and allocate any other memory.

- * (old interface - DEPRECATED - use png_create_read_struct instead).

- */

-extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr))

-    PNG_DEPRECATED;

-#undef png_read_init

-#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \

-    PNG_LIBPNG_VER_STRING,  png_sizeof(png_struct));

-#endif

-

-extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr,

-    png_const_charp user_png_ver, png_size_t png_struct_size));

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr,

-    png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t

-    png_info_size));

-#endif

-

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-/* Initialize png_ptr struct for writing, and allocate any other memory.

- * (old interface - DEPRECATED - use png_create_write_struct instead).

- */

-extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr))

-    PNG_DEPRECATED;

-#undef png_write_init

-#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \

-    PNG_LIBPNG_VER_STRING, png_sizeof(png_struct));

-#endif

-

-extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr,

-    png_const_charp user_png_ver, png_size_t png_struct_size));

-extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr,

-    png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t

-    png_info_size));

-

-/* Allocate memory for an internal libpng struct */

-PNG_EXTERN png_voidp png_create_struct PNGARG((int type)) PNG_PRIVATE;

-

-/* Free memory from internal libpng struct */

-PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)) PNG_PRIVATE;

-

-PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr

-  malloc_fn, png_voidp mem_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,

-   png_free_ptr free_fn, png_voidp mem_ptr)) PNG_PRIVATE;

-

-/* Free any memory that info_ptr points to and reset struct. */

-PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-

-#ifndef PNG_1_0_X

-/* Function to allocate memory for zlib. */

-PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items,

-   uInt size)) PNG_PRIVATE;

-

-/* Function to free memory for zlib */

-PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)) PNG_PRIVATE;

-

-#ifdef PNG_SIZE_T

-/* Function to convert a sizeof an item to png_sizeof item */

-   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size))

-      PNG_PRIVATE;

-#endif

-

-/* Next four functions are used internally as callbacks.  PNGAPI is required

- * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3.

- */

-

-PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,

-   png_bytep data, png_size_t length)) PNG_PRIVATE;

-

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,

-   png_bytep buffer, png_size_t length)) PNG_PRIVATE;

-#endif

-

-PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,

-   png_bytep data, png_size_t length)) PNG_PRIVATE;

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-#ifdef PNG_STDIO_SUPPORTED

-PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr))

-   PNG_PRIVATE;

-#endif

-#endif

-#else /* PNG_1_0_X */

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr,

-   png_bytep buffer, png_size_t length)) PNG_PRIVATE;

-#endif

-#endif /* PNG_1_0_X */

-

-/* Reset the CRC variable */

-PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-/* Write the "data" buffer to whatever output you are using. */

-PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,

-   png_size_t length)) PNG_PRIVATE;

-

-/* Read data from whatever input you are using into the "data" buffer */

-PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,

-   png_size_t length)) PNG_PRIVATE;

-

-/* Read bytes into buf, and update png_ptr->crc */

-PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,

-   png_size_t length)) PNG_PRIVATE;

-

-/* Decompress data in a chunk that uses compression */

-#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \

-    defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)

-PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,

-   int comp_type, png_size_t chunklength,

-   png_size_t prefix_length, png_size_t *data_length)) PNG_PRIVATE;

-#endif

-

-/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */

-PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)

-   PNG_PRIVATE);

-

-/* Read the CRC from the file and compare it to the libpng calculated CRC */

-PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-/* Calculate the CRC over a section of data.  Note that we are only

- * passing a maximum of 64K on systems that have this as a memory limit,

- * since this is the maximum buffer size we can specify.

- */

-PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,

-   png_size_t length)) PNG_PRIVATE;

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-#endif

-

-/* Simple function to write the signature */

-PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-/* Write various chunks */

-

-/* Write the IHDR chunk, and update the png_struct with the necessary

- * information.

- */

-PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,

-   png_uint_32 height,

-   int bit_depth, int color_type, int compression_method, int filter_method,

-   int interlace_method)) PNG_PRIVATE;

-

-PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,

-   png_uint_32 num_pal)) PNG_PRIVATE;

-

-PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,

-   png_size_t length)) PNG_PRIVATE;

-

-PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-#ifdef PNG_WRITE_gAMA_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma))

-    PNG_PRIVATE;

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr,

-    png_fixed_point file_gamma)) PNG_PRIVATE;

-#endif

-#endif

-

-#ifdef PNG_WRITE_sBIT_SUPPORTED

-PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,

-   int color_type)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_cHRM_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,

-   double white_x, double white_y,

-   double red_x, double red_y, double green_x, double green_y,

-   double blue_x, double blue_y)) PNG_PRIVATE;

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,

-   png_fixed_point int_white_x, png_fixed_point int_white_y,

-   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

-   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

-   png_fixed_point int_blue_y)) PNG_PRIVATE;

-#endif

-#endif

-

-#ifdef PNG_WRITE_sRGB_SUPPORTED

-PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,

-   int intent)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_iCCP_SUPPORTED

-PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,

-   png_charp name, int compression_type,

-   png_charp profile, int proflen)) PNG_PRIVATE;

-   /* Note to maintainer: profile should be png_bytep */

-#endif

-

-#ifdef PNG_WRITE_sPLT_SUPPORTED

-PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,

-   png_sPLT_tp palette)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_tRNS_SUPPORTED

-PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,

-   png_color_16p values, int number, int color_type)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_bKGD_SUPPORTED

-PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,

-   png_color_16p values, int color_type)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_hIST_SUPPORTED

-PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,

-   int num_hist)) PNG_PRIVATE;

-#endif

-

-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \

-    defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

-PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,

-   png_charp key, png_charpp new_key)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_tEXt_SUPPORTED

-PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,

-   png_charp text, png_size_t text_len)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_zTXt_SUPPORTED

-PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,

-   png_charp text, png_size_t text_len, int compression)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_iTXt_SUPPORTED

-PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,

-   int compression, png_charp key, png_charp lang, png_charp lang_key,

-   png_charp text)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_TEXT_SUPPORTED  /* Added at version 1.0.14 and 1.2.4 */

-PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_textp text_ptr, int num_text)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_oFFs_SUPPORTED

-PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,

-   png_int_32 x_offset, png_int_32 y_offset, int unit_type)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_pCAL_SUPPORTED

-PNG_EXTERN void png_write_pCAL PNGARG((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_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_pHYs_SUPPORTED

-PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,

-   png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,

-   int unit_type)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_tIME_SUPPORTED

-PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,

-   png_timep mod_time)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_sCAL_SUPPORTED

-#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)

-PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,

-   int unit, double width, double height)) PNG_PRIVATE;

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,

-   int unit, png_charp width, png_charp height)) PNG_PRIVATE;

-#endif

-#endif

-#endif

-

-/* Called when finished processing a row of data */

-PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-/* Internal use only.   Called before first row of data */

-PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-#ifdef PNG_READ_GAMMA_SUPPORTED

-PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-#endif

-

-/* Combine a row of data, dealing with alpha, etc. if requested */

-PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,

-   int mask)) PNG_PRIVATE;

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-/* Expand an interlaced row */

-/* OLD pre-1.0.9 interface:

-PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,

-   png_bytep row, int pass, png_uint_32 transformations)) PNG_PRIVATE;

- */

-PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-#endif

-

-/* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-/* Grab pixels out of a row for an interlaced pass */

-PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,

-   png_bytep row, int pass)) PNG_PRIVATE;

-#endif

-

-/* Unfilter a row */

-PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,

-   png_row_infop row_info, png_bytep row, png_bytep prev_row,

-   int filter)) PNG_PRIVATE;

-

-/* Choose the best filter to use and filter the row data */

-PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,

-   png_row_infop row_info)) PNG_PRIVATE;

-

-/* Write out the filtered row. */

-PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,

-   png_bytep filtered_row)) PNG_PRIVATE;

-/* Finish a row while reading, dealing with interlacing passes, etc. */

-PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));

-

-/* Initialize the row buffers, etc. */

-PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-/* Optional call to update the users info structure */

-PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-

-/* These are the functions that do the transformations */

-#ifdef PNG_READ_FILLER_SUPPORTED

-PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,

-   png_bytep row, png_uint_32 filler, png_uint_32 flags)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,

-   png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,

-   png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,

-   png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,

-   png_bytep row)) PNG_PRIVATE;

-#endif

-

-#if defined(PNG_WRITE_FILLER_SUPPORTED) || \

-    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

-PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,

-   png_bytep row, png_uint_32 flags)) PNG_PRIVATE;

-#endif

-

-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

-PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info,

-    png_bytep row)) PNG_PRIVATE;

-#endif

-

-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)

-PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info,

-    png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop

-   row_info, png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,

-   png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_PACK_SUPPORTED

-PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info,

-    png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_SHIFT_SUPPORTED

-PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_8p sig_bits)) PNG_PRIVATE;

-#endif

-

-#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

-PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info,

-    png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_16_TO_8_SUPPORTED

-PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info,

-    png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,

-   png_bytep row, png_bytep palette_lookup,

-    png_bytep dither_lookup)) PNG_PRIVATE;

-

-#  ifdef PNG_CORRECT_PALETTE_SUPPORTED

-PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,

-   png_colorp palette, int num_palette)) PNG_PRIVATE;

-#  endif

-#endif

-

-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

-PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info,

-    png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_PACK_SUPPORTED

-PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,

-   png_bytep row, png_uint_32 bit_depth)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_WRITE_SHIFT_SUPPORTED

-PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_8p bit_depth)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-#ifdef PNG_READ_GAMMA_SUPPORTED

-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_16p trans_values, png_color_16p background,

-   png_color_16p background_1,

-   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

-   png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

-   png_uint_16pp gamma_16_to_1, int gamma_shift)) PNG_PRIVATE;

-#else

-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_16p trans_values, png_color_16p background)) PNG_PRIVATE;

-#endif

-#endif

-

-#ifdef PNG_READ_GAMMA_SUPPORTED

-PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,

-   png_bytep gamma_table, png_uint_16pp gamma_16_table,

-   int gamma_shift)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,

-   png_bytep row, png_colorp palette, png_bytep trans,

-   int num_trans)) PNG_PRIVATE;

-PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,

-   png_bytep row, png_color_16p trans_value)) PNG_PRIVATE;

-#endif

-

-/* The following decodes the appropriate chunks, and does error correction,

- * then calls the appropriate callback for the chunk if it is valid.

- */

-

-/* Decode the IHDR chunk */

-PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

-PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

-

-#ifdef PNG_READ_bKGD_SUPPORTED

-PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_cHRM_SUPPORTED

-PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_gAMA_SUPPORTED

-PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_hIST_SUPPORTED

-PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_iCCP_SUPPORTED

-extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

-#endif /* PNG_READ_iCCP_SUPPORTED */

-

-#ifdef PNG_READ_iTXt_SUPPORTED

-PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_oFFs_SUPPORTED

-PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_pCAL_SUPPORTED

-PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_pHYs_SUPPORTED

-PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_sBIT_SUPPORTED

-PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_sCAL_SUPPORTED

-PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_sPLT_SUPPORTED

-extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif /* PNG_READ_sPLT_SUPPORTED */

-

-#ifdef PNG_READ_sRGB_SUPPORTED

-PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_tEXt_SUPPORTED

-PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_tIME_SUPPORTED

-PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_tRNS_SUPPORTED

-PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_READ_zTXt_SUPPORTED

-PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-#endif

-

-PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE;

-

-PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,

-   png_bytep chunk_name)) PNG_PRIVATE;

-

-/* Handle the transformations for reading and writing */

-PNG_EXTERN void png_do_read_transformations

-   PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_do_write_transformations

-   PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-PNG_EXTERN void png_init_read_transformations

-   PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,

-   png_uint_32 length)) PNG_PRIVATE;

-PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,

-   png_bytep buffer, png_size_t buffer_length)) PNG_PRIVATE;

-PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,

-   png_bytep buffer, png_size_t buffer_length)) PNG_PRIVATE;

-PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE;

-PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr,

-   png_bytep row)) PNG_PRIVATE;

-PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-PNG_EXTERN void png_read_push_finish_row

-   PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-#ifdef PNG_READ_tEXt_SUPPORTED

-PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE;

-PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE;

-PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE;

-PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr)) PNG_PRIVATE;

-#endif

-

-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,

-   png_bytep row)) PNG_PRIVATE;

-PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,

-   png_bytep row)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

-#ifdef PNG_MMX_CODE_SUPPORTED

-/* png.c */ /* PRIVATE */

-PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-#endif

-#endif

-

-

-/* The following six functions will be exported in libpng-1.4.0. */

-#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)

-PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-

-#ifdef PNG_pHYs_SUPPORTED

-PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr,

-png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));

-#endif /* PNG_pHYs_SUPPORTED */

-#endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */

-

-/* Read the chunk header (length + type name) */

-PNG_EXTERN png_uint_32 png_read_chunk_header

-   PNGARG((png_structp png_ptr)) PNG_PRIVATE;

-

-/* Added at libpng version 1.2.34 */

-#ifdef PNG_cHRM_SUPPORTED

-PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,

-   png_fixed_point int_white_x, png_fixed_point int_white_y,

-   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

-   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

-   png_fixed_point int_blue_y)) PNG_PRIVATE;

-#endif

-

-#ifdef PNG_cHRM_SUPPORTED

-#ifdef PNG_CHECK_cHRM_SUPPORTED

-/* Added at libpng version 1.2.34 */

-PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,

-   unsigned long *hi_product, unsigned long *lo_product)) PNG_PRIVATE;

-#endif

-#endif

-

-/* Added at libpng version 1.2.41 */

-PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,

-   png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_type, int compression_type,

-   int filter_type)) PNG_PRIVATE;

-

-/* Added at libpng version 1.2.41 */

-PNG_EXTERN png_voidp png_calloc PNGARG((png_structp png_ptr,

-   png_uint_32 size));

-

-/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */

-

-#endif /* PNG_INTERNAL */

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif /* PNG_VERSION_INFO_ONLY */

-/* Do not put anything past this line */

-#endif /* PNG_H */

+
+/* png.h - header file for PNG reference library
+ *
+ * libpng version 1.4.0 - January 3, 2010
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license (See LICENSE, below)
+ *
+ * Authors and maintainers:
+ *  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.97, January 1998, through 1.4.0 - January 3, 2010: Glenn
+ *  See also "Contributing Authors", below.
+ *
+ * Note about libpng version numbers:
+ *
+ *    Due to various miscommunications, unforeseen code incompatibilities
+ *    and occasional factors outside the authors' control, version numbering
+ *    on the library has not always been consistent and straightforward.
+ *    The following table summarizes matters since version 0.89c, which was
+ *    the first widely used release:
+ *
+ *    source                 png.h  png.h  shared-lib
+ *    version                string   int  version
+ *    -------                ------ -----  ----------
+ *    0.89c "1.0 beta 3"     0.89      89  1.0.89
+ *    0.90  "1.0 beta 4"     0.90      90  0.90  [should have been 2.0.90]
+ *    0.95  "1.0 beta 5"     0.95      95  0.95  [should have been 2.0.95]
+ *    0.96  "1.0 beta 6"     0.96      96  0.96  [should have been 2.0.96]
+ *    0.97b "1.00.97 beta 7" 1.00.97   97  1.0.1 [should have been 2.0.97]
+ *    0.97c                  0.97      97  2.0.97
+ *    0.98                   0.98      98  2.0.98
+ *    0.99                   0.99      98  2.0.99
+ *    0.99a-m                0.99      99  2.0.99
+ *    1.00                   1.00     100  2.1.0 [100 should be 10000]
+ *    1.0.0      (from here on, the   100  2.1.0 [100 should be 10000]
+ *    1.0.1       png.h string is   10001  2.1.0
+ *    1.0.1a-e    identical to the  10002  from here on, the shared library
+ *    1.0.2       source version)   10002  is 2.V where V is the source code
+ *    1.0.2a-b                      10003  version, except as noted.
+ *    1.0.3                         10003
+ *    1.0.3a-d                      10004
+ *    1.0.4                         10004
+ *    1.0.4a-f                      10005
+ *    1.0.5 (+ 2 patches)           10005
+ *    1.0.5a-d                      10006
+ *    1.0.5e-r                      10100 (not source compatible)
+ *    1.0.5s-v                      10006 (not binary compatible)
+ *    1.0.6 (+ 3 patches)           10006 (still binary incompatible)
+ *    1.0.6d-f                      10007 (still binary incompatible)
+ *    1.0.6g                        10007
+ *    1.0.6h                        10007  10.6h (testing xy.z so-numbering)
+ *    1.0.6i                        10007  10.6i
+ *    1.0.6j                        10007  2.1.0.6j (incompatible with 1.0.0)
+ *    1.0.7beta11-14        DLLNUM  10007  2.1.0.7beta11-14 (binary compatible)
+ *    1.0.7beta15-18           1    10007  2.1.0.7beta15-18 (binary compatible)
+ *    1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)
+ *    1.0.7                    1    10007  (still compatible)
+ *    1.0.8beta1-4             1    10008  2.1.0.8beta1-4
+ *    1.0.8rc1                 1    10008  2.1.0.8rc1
+ *    1.0.8                    1    10008  2.1.0.8
+ *    1.0.9beta1-6             1    10009  2.1.0.9beta1-6
+ *    1.0.9rc1                 1    10009  2.1.0.9rc1
+ *    1.0.9beta7-10            1    10009  2.1.0.9beta7-10
+ *    1.0.9rc2                 1    10009  2.1.0.9rc2
+ *    1.0.9                    1    10009  2.1.0.9
+ *    1.0.10beta1              1    10010  2.1.0.10beta1
+ *    1.0.10rc1                1    10010  2.1.0.10rc1
+ *    1.0.10                   1    10010  2.1.0.10
+ *    1.0.11beta1-3            1    10011  2.1.0.11beta1-3
+ *    1.0.11rc1                1    10011  2.1.0.11rc1
+ *    1.0.11                   1    10011  2.1.0.11
+ *    1.0.12beta1-2            2    10012  2.1.0.12beta1-2
+ *    1.0.12rc1                2    10012  2.1.0.12rc1
+ *    1.0.12                   2    10012  2.1.0.12
+ *    1.1.0a-f                 -    10100  2.1.1.0a-f (branch abandoned)
+ *    1.2.0beta1-2             2    10200  2.1.2.0beta1-2
+ *    1.2.0beta3-5             3    10200  3.1.2.0beta3-5
+ *    1.2.0rc1                 3    10200  3.1.2.0rc1
+ *    1.2.0                    3    10200  3.1.2.0
+ *    1.2.1beta1-4             3    10201  3.1.2.1beta1-4
+ *    1.2.1rc1-2               3    10201  3.1.2.1rc1-2
+ *    1.2.1                    3    10201  3.1.2.1
+ *    1.2.2beta1-6            12    10202  12.so.0.1.2.2beta1-6
+ *    1.0.13beta1             10    10013  10.so.0.1.0.13beta1
+ *    1.0.13rc1               10    10013  10.so.0.1.0.13rc1
+ *    1.2.2rc1                12    10202  12.so.0.1.2.2rc1
+ *    1.0.13                  10    10013  10.so.0.1.0.13
+ *    1.2.2                   12    10202  12.so.0.1.2.2
+ *    1.2.3rc1-6              12    10203  12.so.0.1.2.3rc1-6
+ *    1.2.3                   12    10203  12.so.0.1.2.3
+ *    1.2.4beta1-3            13    10204  12.so.0.1.2.4beta1-3
+ *    1.0.14rc1               13    10014  10.so.0.1.0.14rc1
+ *    1.2.4rc1                13    10204  12.so.0.1.2.4rc1
+ *    1.0.14                  10    10014  10.so.0.1.0.14
+ *    1.2.4                   13    10204  12.so.0.1.2.4
+ *    1.2.5beta1-2            13    10205  12.so.0.1.2.5beta1-2
+ *    1.0.15rc1-3             10    10015  10.so.0.1.0.15rc1-3
+ *    1.2.5rc1-3              13    10205  12.so.0.1.2.5rc1-3
+ *    1.0.15                  10    10015  10.so.0.1.0.15
+ *    1.2.5                   13    10205  12.so.0.1.2.5
+ *    1.2.6beta1-4            13    10206  12.so.0.1.2.6beta1-4
+ *    1.0.16                  10    10016  10.so.0.1.0.16
+ *    1.2.6                   13    10206  12.so.0.1.2.6
+ *    1.2.7beta1-2            13    10207  12.so.0.1.2.7beta1-2
+ *    1.0.17rc1               10    10017  12.so.0.1.0.17rc1
+ *    1.2.7rc1                13    10207  12.so.0.1.2.7rc1
+ *    1.0.17                  10    10017  12.so.0.1.0.17
+ *    1.2.7                   13    10207  12.so.0.1.2.7
+ *    1.2.8beta1-5            13    10208  12.so.0.1.2.8beta1-5
+ *    1.0.18rc1-5             10    10018  12.so.0.1.0.18rc1-5
+ *    1.2.8rc1-5              13    10208  12.so.0.1.2.8rc1-5
+ *    1.0.18                  10    10018  12.so.0.1.0.18
+ *    1.2.8                   13    10208  12.so.0.1.2.8
+ *    1.2.9beta1-3            13    10209  12.so.0.1.2.9beta1-3
+ *    1.2.9beta4-11           13    10209  12.so.0.9[.0]
+ *    1.2.9rc1                13    10209  12.so.0.9[.0]
+ *    1.2.9                   13    10209  12.so.0.9[.0]
+ *    1.2.10beta1-7           13    10210  12.so.0.10[.0]
+ *    1.2.10rc1-2             13    10210  12.so.0.10[.0]
+ *    1.2.10                  13    10210  12.so.0.10[.0]
+ *    1.4.0beta1-5            14    10400  14.so.0.0[.0]
+ *    1.2.11beta1-4           13    10211  12.so.0.11[.0]
+ *    1.4.0beta7-8            14    10400  14.so.0.0[.0]
+ *    1.2.11                  13    10211  12.so.0.11[.0]
+ *    1.2.12                  13    10212  12.so.0.12[.0]
+ *    1.4.0beta9-14           14    10400  14.so.0.0[.0]
+ *    1.2.13                  13    10213  12.so.0.13[.0]
+ *    1.4.0beta15-36          14    10400  14.so.0.0[.0]
+ *    1.4.0beta37-87          14    10400  14.so.14.0[.0]
+ *    1.4.0rc01               14    10400  14.so.14.0[.0]
+ *    1.4.0beta88-109         14    10400  14.so.14.0[.0]
+ *    1.4.0rc02-08            14    10400  14.so.14.0[.0]
+ *    1.4.0                   14    10400  14.so.14.0[.0]
+ *
+ *    Henceforth the source version will match the shared-library major
+ *    and minor numbers; the shared-library major version number will be
+ *    used for changes in backward compatibility, as it is intended.  The
+ *    PNG_LIBPNG_VER macro, which is not used within libpng but is available
+ *    for applications, is an unsigned integer of the form xyyzz corresponding
+ *    to the source version x.y.z (leading zeros in y and z).  Beta versions
+ *    were given the previous public release number plus a letter, until
+ *    version 1.0.6j; from then on they were given the upcoming public
+ *    release number plus "betaNN" or "rcN".
+ *
+ *    Binary incompatibility exists only when applications make direct access
+ *    to the info_ptr or png_ptr members through png.h, and the compiled
+ *    application is loaded with a different version of the library.
+ *
+ *    DLLNUM will change each time there are forward or backward changes
+ *    in binary compatibility (e.g., when a new feature is added).
+ *
+ * See libpng.txt or libpng.3 for more information.  The PNG specification
+ * is available as a W3C Recommendation and as an ISO Specification,
+ * <http://www.w3.org/TR/2003/REC-PNG-20031110/
+ */
+
+/*
+ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+ *
+ * If you modify libpng you may insert additional notices immediately following
+ * this sentence.
+ *
+ * This code is released under the libpng license.
+ *
+ * libpng versions 1.2.6, August 15, 2004, through 1.4.0, January 3, 2010, are
+ * Copyright (c) 2004, 2006-2010 Glenn Randers-Pehrson, and are
+ * distributed according to the same disclaimer and license as libpng-1.2.5
+ * with the following individual added to the list of Contributing Authors:
+ *
+ *    Cosmin Truta
+ *
+ * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are
+ * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
+ * distributed according to the same disclaimer and license as libpng-1.0.6
+ * with the following individuals added to the list of Contributing Authors:
+ *
+ *    Simon-Pierre Cadieux
+ *    Eric S. Raymond
+ *    Gilles Vollant
+ *
+ * and with the following additions to the disclaimer:
+ *
+ *    There is no warranty against interference with your enjoyment of the
+ *    library or against infringement.  There is no warranty that our
+ *    efforts or the library will fulfill any of your particular purposes
+ *    or needs.  This library is provided with all faults, and the entire
+ *    risk of satisfactory quality, performance, accuracy, and effort is with
+ *    the user.
+ *
+ * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+ * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are
+ * distributed according to the same disclaimer and license as libpng-0.96,
+ * with the following individuals added to the list of Contributing Authors:
+ *
+ *    Tom Lane
+ *    Glenn Randers-Pehrson
+ *    Willem van Schaik
+ *
+ * libpng versions 0.89, June 1996, through 0.96, May 1997, are
+ * Copyright (c) 1996, 1997 Andreas Dilger
+ * Distributed according to the same disclaimer and license as libpng-0.88,
+ * with the following individuals added to the list of Contributing Authors:
+ *
+ *    John Bowler
+ *    Kevin Bracey
+ *    Sam Bushell
+ *    Magnus Holmgren
+ *    Greg Roelofs
+ *    Tom Tanner
+ *
+ * libpng versions 0.5, May 1995, through 0.88, January 1996, are
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * For the purposes of this copyright and license, "Contributing Authors"
+ * is defined as the following set of individuals:
+ *
+ *    Andreas Dilger
+ *    Dave Martindale
+ *    Guy Eric Schalnat
+ *    Paul Schmidt
+ *    Tim Wegner
+ *
+ * The PNG Reference Library is supplied "AS IS".  The Contributing Authors
+ * and Group 42, Inc. disclaim all warranties, expressed or implied,
+ * including, without limitation, the warranties of merchantability and of
+ * fitness for any purpose.  The Contributing Authors and Group 42, Inc.
+ * assume no liability for direct, indirect, incidental, special, exemplary,
+ * or consequential damages, which may result from the use of the PNG
+ * Reference Library, even if advised of the possibility of such damage.
+ *
+ * Permission is hereby granted to use, copy, modify, and distribute this
+ * source code, or portions hereof, for any purpose, without fee, subject
+ * to the following restrictions:
+ *
+ * 1. The origin of this source code must not be misrepresented.
+ *
+ * 2. Altered versions must be plainly marked as such and
+ * must not be misrepresented as being the original source.
+ *
+ * 3. This Copyright notice may not be removed or altered from
+ *    any source or altered source distribution.
+ *
+ * The Contributing Authors and Group 42, Inc. specifically permit, without
+ * fee, and encourage the use of this source code as a component to
+ * supporting the PNG file format in commercial products.  If you use this
+ * source code in a product, acknowledgment is not required but would be
+ * appreciated.
+ */
+
+/*
+ * A "png_get_copyright" function is available, for convenient use in "about"
+ * boxes and the like:
+ *
+ *     printf("%s",png_get_copyright(NULL));
+ *
+ * Also, the PNG logo (in PNG format, of course) is supplied in the
+ * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+ */
+
+/*
+ * Libpng is OSI Certified Open Source Software.  OSI Certified is a
+ * certification mark of the Open Source Initiative.
+ */
+
+/*
+ * The contributing authors would like to thank all those who helped
+ * with testing, bug fixes, and patience.  This wouldn't have been
+ * possible without all of you.
+ *
+ * Thanks to Frank J. T. Wojcik for helping with the documentation.
+ */
+
+/*
+ * Y2K compliance in libpng:
+ * =========================
+ *
+ *    January 3, 2010
+ *
+ *    Since the PNG Development group is an ad-hoc body, we can't make
+ *    an official declaration.
+ *
+ *    This is your unofficial assurance that libpng from version 0.71 and
+ *    upward through 1.4.0 are Y2K compliant.  It is my belief that earlier
+ *    versions were also Y2K compliant.
+ *
+ *    Libpng only has three year fields.  One is a 2-byte unsigned integer
+ *    that will hold years up to 65535.  The other two hold the date in text
+ *    format, and will hold years up to 9999.
+ *
+ *    The integer is
+ *        "png_uint_16 year" in png_time_struct.
+ *
+ *    The strings are
+ *        "png_charp time_buffer" in png_struct and
+ *        "near_time_buffer", which is a local character string in png.c.
+ *
+ *    There are seven time-related functions:
+ *        png.c: png_convert_to_rfc_1123() in png.c
+ *          (formerly png_convert_to_rfc_1152() in error)
+ *        png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
+ *        png_convert_from_time_t() in pngwrite.c
+ *        png_get_tIME() in pngget.c
+ *        png_handle_tIME() in pngrutil.c, called in pngread.c
+ *        png_set_tIME() in pngset.c
+ *        png_write_tIME() in pngwutil.c, called in pngwrite.c
+ *
+ *    All handle dates properly in a Y2K environment.  The
+ *    png_convert_from_time_t() function calls gmtime() to convert from system
+ *    clock time, which returns (year - 1900), which we properly convert to
+ *    the full 4-digit year.  There is a possibility that applications using
+ *    libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
+ *    function, or that they are incorrectly passing only a 2-digit year
+ *    instead of "year - 1900" into the png_convert_from_struct_tm() function,
+ *    but this is not under our control.  The libpng documentation has always
+ *    stated that it works with 4-digit years, and the APIs have been
+ *    documented as such.
+ *
+ *    The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
+ *    integer to hold the year, and can hold years as large as 65535.
+ *
+ *    zlib, upon which libpng depends, is also Y2K compliant.  It contains
+ *    no date-related code.
+ *
+ *       Glenn Randers-Pehrson
+ *       libpng maintainer
+ *       PNG Development Group
+ */
+
+#ifndef PNG_H
+#define PNG_H
+
+/* This is not the place to learn how to use libpng.  The file libpng.txt
+ * describes how to use libpng, and the file example.c summarizes it
+ * with some code on which to build.  This file is useful for looking
+ * at the actual function definitions and structure components.
+ */
+
+/* Version information for png.h - this should match the version in png.c */
+#define PNG_LIBPNG_VER_STRING "1.4.0"
+#define PNG_HEADER_VERSION_STRING \
+   " libpng version 1.4.0 - January 3, 2010\n"
+
+#define PNG_LIBPNG_VER_SONUM   14
+#define PNG_LIBPNG_VER_DLLNUM  14
+
+/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
+#define PNG_LIBPNG_VER_MAJOR   1
+#define PNG_LIBPNG_VER_MINOR   4
+#define PNG_LIBPNG_VER_RELEASE 0
+/* This should match the numeric part of the final component of
+ * PNG_LIBPNG_VER_STRING, omitting any leading zero:
+ */
+
+#define PNG_LIBPNG_VER_BUILD  0
+
+/* Release Status */
+#define PNG_LIBPNG_BUILD_ALPHA    1
+#define PNG_LIBPNG_BUILD_BETA     2
+#define PNG_LIBPNG_BUILD_RC       3
+#define PNG_LIBPNG_BUILD_STABLE   4
+#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7
+
+/* Release-Specific Flags */
+#define PNG_LIBPNG_BUILD_PATCH    8 /* Can be OR'ed with
+                                       PNG_LIBPNG_BUILD_STABLE only */
+#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with
+                                       PNG_LIBPNG_BUILD_SPECIAL */
+#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
+                                       PNG_LIBPNG_BUILD_PRIVATE */
+
+#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.
+ * We must not include leading zeros.
+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
+ * version 1.0.0 was mis-numbered 100 instead of 10000).  From
+ * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release
+ */
+#define PNG_LIBPNG_VER 10400 /* 1.4.0 */
+
+#ifndef PNG_VERSION_INFO_ONLY
+/* Include the compression library's header */
+#include "zlib.h"
+#endif
+
+#ifdef AIX
+#define jmpbuf __jmpbuf
+#endif
+
+/* Include all user configurable info, including optional assembler routines */
+#include "pngconf.h"
+
+/*
+ * Added at libpng-1.2.8
+ *
+ * Ref MSDN: Private as priority over Special
+ * VS_FF_PRIVATEBUILD File *was not* built using standard release
+ * procedures. If this value is given, the StringFileInfo block must
+ * contain a PrivateBuild string.
+ *
+ * VS_FF_SPECIALBUILD File *was* built by the original company using
+ * standard release procedures but is a variation of the standard
+ * file of the same version number. If this value is given, the
+ * StringFileInfo block must contain a SpecialBuild string.
+ */
+
+#ifdef PNG_USER_PRIVATEBUILD
+#  define PNG_LIBPNG_BUILD_TYPE \
+          (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)
+#else
+#  ifdef PNG_LIBPNG_SPECIALBUILD
+#    define PNG_LIBPNG_BUILD_TYPE \
+            (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)
+#  else
+#    define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)
+#  endif
+#endif
+
+#ifndef PNG_VERSION_INFO_ONLY
+
+/* Inhibit C++ name-mangling for libpng functions but not for system calls. */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* This file is arranged in several sections.  The first section contains
+ * structure and type definitions.  The second section contains the external
+ * library functions, while the third has the internal library functions,
+ * which applications aren't expected to use directly.
+ */
+
+/* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */
+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
+/* Version information for C files, stored in png.c.  This had better match
+ * the version above.
+ */
+#define png_libpng_ver png_get_header_ver(NULL)
+
+#endif /* PNG_NO_EXTERN */
+
+/* Three color definitions.  The order of the red, green, and blue, (and the
+ * exact size) is not important, although the size of the fields need to
+ * be png_byte or png_uint_16 (as defined below).
+ */
+typedef struct png_color_struct
+{
+   png_byte red;
+   png_byte green;
+   png_byte blue;
+} png_color;
+typedef png_color FAR * png_colorp;
+typedef png_color FAR * FAR * png_colorpp;
+
+typedef struct png_color_16_struct
+{
+   png_byte index;    /* used for palette files */
+   png_uint_16 red;   /* for use in red green blue files */
+   png_uint_16 green;
+   png_uint_16 blue;
+   png_uint_16 gray;  /* for use in grayscale files */
+} png_color_16;
+typedef png_color_16 FAR * png_color_16p;
+typedef png_color_16 FAR * FAR * png_color_16pp;
+
+typedef struct png_color_8_struct
+{
+   png_byte red;   /* for use in red green blue files */
+   png_byte green;
+   png_byte blue;
+   png_byte gray;  /* for use in grayscale files */
+   png_byte alpha; /* for alpha channel files */
+} png_color_8;
+typedef png_color_8 FAR * png_color_8p;
+typedef png_color_8 FAR * FAR * png_color_8pp;
+
+/*
+ * The following two structures are used for the in-core representation
+ * of sPLT chunks.
+ */
+typedef struct png_sPLT_entry_struct
+{
+   png_uint_16 red;
+   png_uint_16 green;
+   png_uint_16 blue;
+   png_uint_16 alpha;
+   png_uint_16 frequency;
+} png_sPLT_entry;
+typedef png_sPLT_entry FAR * png_sPLT_entryp;
+typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;
+
+/*  When the depth of the sPLT palette is 8 bits, the color and alpha samples
+ *  occupy the LSB of their respective members, and the MSB of each member
+ *  is zero-filled.  The frequency member always occupies the full 16 bits.
+ */
+
+typedef struct png_sPLT_struct
+{
+   png_charp name;           /* palette name */
+   png_byte depth;           /* depth of palette samples */
+   png_sPLT_entryp entries;  /* palette entries */
+   png_int_32 nentries;      /* number of palette entries */
+} png_sPLT_t;
+typedef png_sPLT_t FAR * png_sPLT_tp;
+typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;
+
+#ifdef PNG_TEXT_SUPPORTED
+/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
+ * and whether that contents is compressed or not.  The "key" field
+ * points to a regular zero-terminated C string.  The "text", "lang", and
+ * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.
+ * However, the * structure returned by png_get_text() will always contain
+ * regular zero-terminated C strings (possibly empty), never NULL pointers,
+ * so they can be safely used in printf() and other string-handling functions.
+ */
+typedef struct png_text_struct
+{
+   int  compression;       /* compression value:
+                             -1: tEXt, none
+                              0: zTXt, deflate
+                              1: iTXt, none
+                              2: iTXt, deflate  */
+   png_charp key;          /* keyword, 1-79 character description of "text" */
+   png_charp text;         /* comment, may be an empty string (ie "")
+                              or a NULL pointer */
+   png_size_t text_length; /* length of the text string */
+#ifdef PNG_iTXt_SUPPORTED
+   png_size_t itxt_length; /* length of the itxt string */
+   png_charp lang;         /* language code, 0-79 characters
+                              or a NULL pointer */
+   png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more
+                              chars or a NULL pointer */
+#endif
+} png_text;
+typedef png_text FAR * png_textp;
+typedef png_text FAR * FAR * png_textpp;
+#endif
+
+/* Supported compression types for text in PNG files (tEXt, and zTXt).
+ * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */
+#define PNG_TEXT_COMPRESSION_NONE_WR -3
+#define PNG_TEXT_COMPRESSION_zTXt_WR -2
+#define PNG_TEXT_COMPRESSION_NONE    -1
+#define PNG_TEXT_COMPRESSION_zTXt     0
+#define PNG_ITXT_COMPRESSION_NONE     1
+#define PNG_ITXT_COMPRESSION_zTXt     2
+#define PNG_TEXT_COMPRESSION_LAST     3  /* Not a valid value */
+
+/* png_time is a way to hold the time in an machine independent way.
+ * Two conversions are provided, both from time_t and struct tm.  There
+ * is no portable way to convert to either of these structures, as far
+ * as I know.  If you know of a portable way, send it to me.  As a side
+ * note - PNG has always been Year 2000 compliant!
+ */
+typedef struct png_time_struct
+{
+   png_uint_16 year; /* full year, as in, 1995 */
+   png_byte month;   /* month of year, 1 - 12 */
+   png_byte day;     /* day of month, 1 - 31 */
+   png_byte hour;    /* hour of day, 0 - 23 */
+   png_byte minute;  /* minute of hour, 0 - 59 */
+   png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */
+} png_time;
+typedef png_time FAR * png_timep;
+typedef png_time FAR * FAR * png_timepp;
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \
+ defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
+/* png_unknown_chunk is a structure to hold queued chunks for which there is
+ * no specific support.  The idea is that we can use this to queue
+ * up private chunks for output even though the library doesn't actually
+ * know about their semantics.
+ */
+typedef struct png_unknown_chunk_t
+{
+    png_byte name[5];
+    png_byte *data;
+    png_size_t size;
+
+    /* libpng-using applications should NOT directly modify this byte. */
+    png_byte location; /* mode of operation at read time */
+}
+png_unknown_chunk;
+typedef png_unknown_chunk FAR * png_unknown_chunkp;
+typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;
+#endif
+
+/* png_info is a structure that holds the information in a PNG file so
+ * that the application can find out the characteristics of the image.
+ * If you are reading the file, this structure will tell you what is
+ * in the PNG file.  If you are writing the file, fill in the information
+ * you want to put into the PNG file, then call png_write_info().
+ * The names chosen should be very close to the PNG specification, so
+ * consult that document for information about the meaning of each field.
+ *
+ * With libpng < 0.95, it was only possible to directly set and read the
+ * the values in the png_info_struct, which meant that the contents and
+ * order of the values had to remain fixed.  With libpng 0.95 and later,
+ * however, there are now functions that abstract the contents of
+ * png_info_struct from the application, so this makes it easier to use
+ * libpng with dynamic libraries, and even makes it possible to use
+ * libraries that don't have all of the libpng ancillary chunk-handing
+ * functionality.
+ *
+ * In any case, the order of the parameters in png_info_struct should NOT
+ * be changed for as long as possible to keep compatibility with applications
+ * that use the old direct-access method with png_info_struct.
+ *
+ * The following members may have allocated storage attached that should be
+ * cleaned up before the structure is discarded: palette, trans, text,
+ * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,
+ * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these
+ * are automatically freed when the info structure is deallocated, if they were
+ * allocated internally by libpng.  This behavior can be changed by means
+ * of the png_data_freer() function.
+ *
+ * More allocation details: all the chunk-reading functions that
+ * change these members go through the corresponding png_set_*
+ * functions.  A function to clear these members is available: see
+ * png_free_data().  The png_set_* functions do not depend on being
+ * able to point info structure members to any of the storage they are
+ * passed (they make their own copies), EXCEPT that the png_set_text
+ * functions use the same storage passed to them in the text_ptr or
+ * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns
+ * functions do not make their own copies.
+ */
+typedef struct png_info_struct
+{
+   /* the following are necessary for every PNG file */
+   png_uint_32 width PNG_DEPSTRUCT;       /* width of image in pixels (from IHDR) */
+   png_uint_32 height PNG_DEPSTRUCT;      /* height of image in pixels (from IHDR) */
+   png_uint_32 valid PNG_DEPSTRUCT;       /* valid chunk data (see PNG_INFO_ below) */
+   png_size_t rowbytes PNG_DEPSTRUCT;     /* bytes needed to hold an untransformed row */
+   png_colorp palette PNG_DEPSTRUCT;      /* array of color values (valid & PNG_INFO_PLTE) */
+   png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in "palette" (PLTE) */
+   png_uint_16 num_trans PNG_DEPSTRUCT;   /* number of transparent palette color (tRNS) */
+   png_byte bit_depth PNG_DEPSTRUCT;      /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */
+   png_byte color_type PNG_DEPSTRUCT;     /* see PNG_COLOR_TYPE_ below (from IHDR) */
+   /* The following three should have been named *_method not *_type */
+   png_byte compression_type PNG_DEPSTRUCT; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */
+   png_byte filter_type PNG_DEPSTRUCT;    /* must be PNG_FILTER_TYPE_BASE (from IHDR) */
+   png_byte interlace_type PNG_DEPSTRUCT; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
+
+   /* The following is informational only on read, and not used on writes. */
+   png_byte channels PNG_DEPSTRUCT;       /* number of data channels per pixel (1, 2, 3, 4) */
+   png_byte pixel_depth PNG_DEPSTRUCT;    /* number of bits per pixel */
+   png_byte spare_byte PNG_DEPSTRUCT;     /* to align the data, and for future use */
+   png_byte signature[8] PNG_DEPSTRUCT;   /* magic bytes read by libpng from start of file */
+
+   /* The rest of the data is optional.  If you are reading, check the
+    * valid field to see if the information in these are valid.  If you
+    * are writing, set the valid field to those chunks you want written,
+    * and initialize the appropriate fields below.
+    */
+
+#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+   /* The gAMA chunk describes the gamma characteristics of the system
+    * on which the image was created, normally in the range [1.0, 2.5].
+    * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.
+    */
+   float gamma PNG_DEPSTRUCT; /* gamma value of image, if (valid & PNG_INFO_gAMA) */
+#endif
+
+#ifdef PNG_sRGB_SUPPORTED
+    /* GR-P, 0.96a */
+    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */
+   png_byte srgb_intent PNG_DEPSTRUCT; /* sRGB rendering intent [0, 1, 2, or 3] */
+#endif
+
+#ifdef PNG_TEXT_SUPPORTED
+   /* The tEXt, and zTXt chunks contain human-readable textual data in
+    * uncompressed, compressed, and optionally compressed forms, respectively.
+    * The data in "text" is an array of pointers to uncompressed,
+    * null-terminated C strings. Each chunk has a keyword that describes the
+    * textual data contained in that chunk.  Keywords are not required to be
+    * unique, and the text string may be empty.  Any number of text chunks may
+    * be in an image.
+    */
+   int num_text PNG_DEPSTRUCT; /* number of comments read/to write */
+   int max_text PNG_DEPSTRUCT; /* current size of text array */
+   png_textp text PNG_DEPSTRUCT; /* array of comments read/to write */
+#endif /* PNG_TEXT_SUPPORTED */
+
+#ifdef PNG_tIME_SUPPORTED
+   /* The tIME chunk holds the last time the displayed image data was
+    * modified.  See the png_time struct for the contents of this struct.
+    */
+   png_time mod_time PNG_DEPSTRUCT;
+#endif
+
+#ifdef PNG_sBIT_SUPPORTED
+   /* The sBIT chunk specifies the number of significant high-order bits
+    * in the pixel data.  Values are in the range [1, bit_depth], and are
+    * only specified for the channels in the pixel data.  The contents of
+    * the low-order bits is not specified.  Data is valid if
+    * (valid & PNG_INFO_sBIT) is non-zero.
+    */
+   png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in color channels */
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \
+defined(PNG_READ_BACKGROUND_SUPPORTED)
+   /* The tRNS chunk supplies transparency data for paletted images and
+    * other image types that don't need a full alpha channel.  There are
+    * "num_trans" transparency values for a paletted image, stored in the
+    * same order as the palette colors, starting from index 0.  Values
+    * for the data are in the range [0, 255], ranging from fully transparent
+    * to fully opaque, respectively.  For non-paletted images, there is a
+    * single color specified that should be treated as fully transparent.
+    * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.
+    */
+   png_bytep trans_alpha PNG_DEPSTRUCT;    /* alpha values for paletted image */
+   png_color_16 trans_color PNG_DEPSTRUCT; /* transparent color for non-palette image */
+#endif
+
+#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   /* The bKGD chunk gives the suggested image background color if the
+    * display program does not have its own background color and the image
+    * is needs to composited onto a background before display.  The colors
+    * in "background" are normally in the same color space/depth as the
+    * pixel data.  Data is valid if (valid & PNG_INFO_bKGD) is non-zero.
+    */
+   png_color_16 background PNG_DEPSTRUCT;
+#endif
+
+#ifdef PNG_oFFs_SUPPORTED
+   /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards
+    * and downwards from the top-left corner of the display, page, or other
+    * application-specific co-ordinate space.  See the PNG_OFFSET_ defines
+    * below for the unit types.  Valid if (valid & PNG_INFO_oFFs) non-zero.
+    */
+   png_int_32 x_offset PNG_DEPSTRUCT; /* x offset on page */
+   png_int_32 y_offset PNG_DEPSTRUCT; /* y offset on page */
+   png_byte offset_unit_type PNG_DEPSTRUCT; /* offset units type */
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+   /* The pHYs chunk gives the physical pixel density of the image for
+    * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_
+    * defines below).  Data is valid if (valid & PNG_INFO_pHYs) is non-zero.
+    */
+   png_uint_32 x_pixels_per_unit PNG_DEPSTRUCT; /* horizontal pixel density */
+   png_uint_32 y_pixels_per_unit PNG_DEPSTRUCT; /* vertical pixel density */
+   png_byte phys_unit_type PNG_DEPSTRUCT; /* resolution type (see PNG_RESOLUTION_ below) */
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+   /* The hIST chunk contains the relative frequency or importance of the
+    * various palette entries, so that a viewer can intelligently select a
+    * reduced-color palette, if required.  Data is an array of "num_palette"
+    * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)
+    * is non-zero.
+    */
+   png_uint_16p hist PNG_DEPSTRUCT;
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+   /* The cHRM chunk describes the CIE color characteristics of the monitor
+    * on which the PNG was created.  This data allows the viewer to do gamut
+    * mapping of the input image to ensure that the viewer sees the same
+    * colors in the image as the creator.  Values are in the range
+    * [0.0, 0.8].  Data valid if (valid & PNG_INFO_cHRM) non-zero.
+    */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   float x_white PNG_DEPSTRUCT;
+   float y_white PNG_DEPSTRUCT;
+   float x_red PNG_DEPSTRUCT;
+   float y_red PNG_DEPSTRUCT;
+   float x_green PNG_DEPSTRUCT;
+   float y_green PNG_DEPSTRUCT;
+   float x_blue PNG_DEPSTRUCT;
+   float y_blue PNG_DEPSTRUCT;
+#endif
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+   /* The pCAL chunk describes a transformation between the stored pixel
+    * values and original physical data values used to create the image.
+    * The integer range [0, 2^bit_depth - 1] maps to the floating-point
+    * range given by [pcal_X0, pcal_X1], and are further transformed by a
+    * (possibly non-linear) transformation function given by "pcal_type"
+    * and "pcal_params" into "pcal_units".  Please see the PNG_EQUATION_
+    * defines below, and the PNG-Group's PNG extensions document for a
+    * complete description of the transformations and how they should be
+    * implemented, and for a description of the ASCII parameter strings.
+    * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.
+    */
+   png_charp pcal_purpose PNG_DEPSTRUCT;  /* pCAL chunk description string */
+   png_int_32 pcal_X0 PNG_DEPSTRUCT;      /* minimum value */
+   png_int_32 pcal_X1 PNG_DEPSTRUCT;      /* maximum value */
+   png_charp pcal_units PNG_DEPSTRUCT;    /* Latin-1 string giving physical units */
+   png_charpp pcal_params PNG_DEPSTRUCT;  /* ASCII strings containing parameter values */
+   png_byte pcal_type PNG_DEPSTRUCT;      /* equation type (see PNG_EQUATION_ below) */
+   png_byte pcal_nparams PNG_DEPSTRUCT;   /* number of parameters given in pcal_params */
+#endif
+
+/* New members added in libpng-1.0.6 */
+   png_uint_32 free_me PNG_DEPSTRUCT;     /* flags items libpng is responsible for freeing */
+
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \
+ defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
+   /* Storage for unknown chunks that the library doesn't recognize. */
+   png_unknown_chunkp unknown_chunks PNG_DEPSTRUCT;
+   png_size_t unknown_chunks_num PNG_DEPSTRUCT;
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+   /* iCCP chunk data. */
+   png_charp iccp_name PNG_DEPSTRUCT;     /* profile name */
+   png_charp iccp_profile PNG_DEPSTRUCT;  /* International Color Consortium profile data */
+                            /* Note to maintainer: should be png_bytep */
+   png_uint_32 iccp_proflen PNG_DEPSTRUCT;  /* ICC profile data length */
+   png_byte iccp_compression PNG_DEPSTRUCT; /* Always zero */
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+   /* Data on sPLT chunks (there may be more than one). */
+   png_sPLT_tp splt_palettes PNG_DEPSTRUCT;
+   png_uint_32 splt_palettes_num PNG_DEPSTRUCT;
+#endif
+
+#ifdef PNG_sCAL_SUPPORTED
+   /* The sCAL chunk describes the actual physical dimensions of the
+    * subject matter of the graphic.  The chunk contains a unit specification
+    * a byte value, and two ASCII strings representing floating-point
+    * values.  The values are width and height corresponsing to one pixel
+    * in the image.  This external representation is converted to double
+    * here.  Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.
+    */
+   png_byte scal_unit PNG_DEPSTRUCT;         /* unit of physical scale */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   double scal_pixel_width PNG_DEPSTRUCT;    /* width of one pixel */
+   double scal_pixel_height PNG_DEPSTRUCT;   /* height of one pixel */
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   png_charp scal_s_width PNG_DEPSTRUCT;     /* string containing height */
+   png_charp scal_s_height PNG_DEPSTRUCT;    /* string containing width */
+#endif
+#endif
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+   /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */
+   /* Data valid if (valid & PNG_INFO_IDAT) non-zero */
+   png_bytepp row_pointers PNG_DEPSTRUCT;        /* the image bits */
+#endif
+
+#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED)
+   png_fixed_point int_gamma PNG_DEPSTRUCT; /* gamma of image, if (valid & PNG_INFO_gAMA) */
+#endif
+
+#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED)
+   png_fixed_point int_x_white PNG_DEPSTRUCT;
+   png_fixed_point int_y_white PNG_DEPSTRUCT;
+   png_fixed_point int_x_red PNG_DEPSTRUCT;
+   png_fixed_point int_y_red PNG_DEPSTRUCT;
+   png_fixed_point int_x_green PNG_DEPSTRUCT;
+   png_fixed_point int_y_green PNG_DEPSTRUCT;
+   png_fixed_point int_x_blue PNG_DEPSTRUCT;
+   png_fixed_point int_y_blue PNG_DEPSTRUCT;
+#endif
+
+} png_info;
+
+typedef png_info FAR * png_infop;
+typedef png_info FAR * FAR * png_infopp;
+
+/* Maximum positive integer used in PNG is (2^31)-1 */
+#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
+#define PNG_UINT_32_MAX ((png_uint_32)(-1))
+#define PNG_SIZE_MAX ((png_size_t)(-1))
+
+/* These describe the color_type field in png_info. */
+/* color type masks */
+#define PNG_COLOR_MASK_PALETTE    1
+#define PNG_COLOR_MASK_COLOR      2
+#define PNG_COLOR_MASK_ALPHA      4
+
+/* color types.  Note that not all combinations are legal */
+#define PNG_COLOR_TYPE_GRAY 0
+#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
+#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)
+#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
+#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
+/* aliases */
+#define PNG_COLOR_TYPE_RGBA  PNG_COLOR_TYPE_RGB_ALPHA
+#define PNG_COLOR_TYPE_GA  PNG_COLOR_TYPE_GRAY_ALPHA
+
+/* This is for compression type. PNG 1.0-1.2 only define the single type. */
+#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */
+#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE
+
+/* This is for filter type. PNG 1.0-1.2 only define the single type. */
+#define PNG_FILTER_TYPE_BASE      0 /* Single row per-byte filtering */
+#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */
+#define PNG_FILTER_TYPE_DEFAULT   PNG_FILTER_TYPE_BASE
+
+/* These are for the interlacing type.  These values should NOT be changed. */
+#define PNG_INTERLACE_NONE        0 /* Non-interlaced image */
+#define PNG_INTERLACE_ADAM7       1 /* Adam7 interlacing */
+#define PNG_INTERLACE_LAST        2 /* Not a valid value */
+
+/* These are for the oFFs chunk.  These values should NOT be changed. */
+#define PNG_OFFSET_PIXEL          0 /* Offset in pixels */
+#define PNG_OFFSET_MICROMETER     1 /* Offset in micrometers (1/10^6 meter) */
+#define PNG_OFFSET_LAST           2 /* Not a valid value */
+
+/* These are for the pCAL chunk.  These values should NOT be changed. */
+#define PNG_EQUATION_LINEAR       0 /* Linear transformation */
+#define PNG_EQUATION_BASE_E       1 /* Exponential base e transform */
+#define PNG_EQUATION_ARBITRARY    2 /* Arbitrary base exponential transform */
+#define PNG_EQUATION_HYPERBOLIC   3 /* Hyperbolic sine transformation */
+#define PNG_EQUATION_LAST         4 /* Not a valid value */
+
+/* These are for the sCAL chunk.  These values should NOT be changed. */
+#define PNG_SCALE_UNKNOWN         0 /* unknown unit (image scale) */
+#define PNG_SCALE_METER           1 /* meters per pixel */
+#define PNG_SCALE_RADIAN          2 /* radians per pixel */
+#define PNG_SCALE_LAST            3 /* Not a valid value */
+
+/* These are for the pHYs chunk.  These values should NOT be changed. */
+#define PNG_RESOLUTION_UNKNOWN    0 /* pixels/unknown unit (aspect ratio) */
+#define PNG_RESOLUTION_METER      1 /* pixels/meter */
+#define PNG_RESOLUTION_LAST       2 /* Not a valid value */
+
+/* These are for the sRGB chunk.  These values should NOT be changed. */
+#define PNG_sRGB_INTENT_PERCEPTUAL 0
+#define PNG_sRGB_INTENT_RELATIVE   1
+#define PNG_sRGB_INTENT_SATURATION 2
+#define PNG_sRGB_INTENT_ABSOLUTE   3
+#define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */
+
+/* This is for text chunks */
+#define PNG_KEYWORD_MAX_LENGTH     79
+
+/* Maximum number of entries in PLTE/sPLT/tRNS arrays */
+#define PNG_MAX_PALETTE_LENGTH    256
+
+/* These determine if an ancillary chunk's data has been successfully read
+ * from the PNG header, or if the application has filled in the corresponding
+ * data in the info_struct to be written into the output file.  The values
+ * of the PNG_INFO_<chunk> defines should NOT be changed.
+ */
+#define PNG_INFO_gAMA 0x0001
+#define PNG_INFO_sBIT 0x0002
+#define PNG_INFO_cHRM 0x0004
+#define PNG_INFO_PLTE 0x0008
+#define PNG_INFO_tRNS 0x0010
+#define PNG_INFO_bKGD 0x0020
+#define PNG_INFO_hIST 0x0040
+#define PNG_INFO_pHYs 0x0080
+#define PNG_INFO_oFFs 0x0100
+#define PNG_INFO_tIME 0x0200
+#define PNG_INFO_pCAL 0x0400
+#define PNG_INFO_sRGB 0x0800   /* GR-P, 0.96a */
+#define PNG_INFO_iCCP 0x1000   /* ESR, 1.0.6 */
+#define PNG_INFO_sPLT 0x2000   /* ESR, 1.0.6 */
+#define PNG_INFO_sCAL 0x4000   /* ESR, 1.0.6 */
+#define PNG_INFO_IDAT 0x8000L  /* ESR, 1.0.6 */
+
+/* This is used for the transformation routines, as some of them
+ * change these values for the row.  It also should enable using
+ * the routines for other purposes.
+ */
+typedef struct png_row_info_struct
+{
+   png_uint_32 width; /* width of row */
+   png_size_t rowbytes; /* number of bytes in row */
+   png_byte color_type; /* color type of row */
+   png_byte bit_depth; /* bit depth of row */
+   png_byte channels; /* number of channels (1, 2, 3, or 4) */
+   png_byte pixel_depth; /* bits per pixel (depth * channels) */
+} png_row_info;
+
+typedef png_row_info FAR * png_row_infop;
+typedef png_row_info FAR * FAR * png_row_infopp;
+
+/* These are the function types for the I/O functions and for the functions
+ * that allow the user to override the default I/O functions with his or her
+ * own.  The png_error_ptr type should match that of user-supplied warning
+ * and error functions, while the png_rw_ptr type should match that of the
+ * user read/write data functions.
+ */
+typedef struct png_struct_def png_struct;
+typedef png_struct FAR * png_structp;
+
+typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));
+typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));
+typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));
+typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,
+   int));
+typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,
+   int));
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop));
+typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));
+typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,
+   png_uint_32, int));
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,
+    png_row_infop, png_bytep));
+#endif
+
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));
+#endif
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));
+#endif
+#ifdef PNG_SETJMP_SUPPORTED
+/* This must match the function definition in <setjmp.h>, and the
+ * application must include this before png.h to obtain the definition
+ * of jmp_buf.
+ */
+typedef void (PNGAPI *png_longjmp_ptr) PNGARG((jmp_buf, int));
+#endif
+
+/* Transform masks for the high-level interface */
+#define PNG_TRANSFORM_IDENTITY       0x0000    /* read and write */
+#define PNG_TRANSFORM_STRIP_16       0x0001    /* read only */
+#define PNG_TRANSFORM_STRIP_ALPHA    0x0002    /* read only */
+#define PNG_TRANSFORM_PACKING        0x0004    /* read and write */
+#define PNG_TRANSFORM_PACKSWAP       0x0008    /* read and write */
+#define PNG_TRANSFORM_EXPAND         0x0010    /* read only */
+#define PNG_TRANSFORM_INVERT_MONO    0x0020    /* read and write */
+#define PNG_TRANSFORM_SHIFT          0x0040    /* read and write */
+#define PNG_TRANSFORM_BGR            0x0080    /* read and write */
+#define PNG_TRANSFORM_SWAP_ALPHA     0x0100    /* read and write */
+#define PNG_TRANSFORM_SWAP_ENDIAN    0x0200    /* read and write */
+#define PNG_TRANSFORM_INVERT_ALPHA   0x0400    /* read and write */
+#define PNG_TRANSFORM_STRIP_FILLER   0x0800    /* write only */
+/* Added to libpng-1.2.34 */
+#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER
+#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */
+/* Added to libpng-1.4.0 */
+#define PNG_TRANSFORM_GRAY_TO_RGB   0x2000      /* read only */
+
+/* Flags for MNG supported features */
+#define PNG_FLAG_MNG_EMPTY_PLTE     0x01
+#define PNG_FLAG_MNG_FILTER_64      0x04
+#define PNG_ALL_MNG_FEATURES        0x05
+
+typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_alloc_size_t));
+typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));
+
+/* The structure that holds the information to read and write PNG files.
+ * The only people who need to care about what is inside of this are the
+ * people who will be modifying the library for their own special needs.
+ * It should NOT be accessed directly by an application, except to store
+ * the jmp_buf.
+ */
+
+struct png_struct_def
+{
+#ifdef PNG_SETJMP_SUPPORTED
+   jmp_buf jmpbuf PNG_DEPSTRUCT;            /* used in png_error */
+   png_longjmp_ptr longjmp_fn PNG_DEPSTRUCT;/* setjmp non-local goto function. */
+#endif
+   png_error_ptr error_fn PNG_DEPSTRUCT;    /* function for printing errors and aborting */
+   png_error_ptr warning_fn PNG_DEPSTRUCT;  /* function for printing warnings */
+   png_voidp error_ptr PNG_DEPSTRUCT;       /* user supplied struct for error functions */
+   png_rw_ptr write_data_fn PNG_DEPSTRUCT;  /* function for writing output data */
+   png_rw_ptr read_data_fn PNG_DEPSTRUCT;   /* function for reading input data */
+   png_voidp io_ptr PNG_DEPSTRUCT;          /* ptr to application struct for I/O functions */
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+   png_user_transform_ptr read_user_transform_fn PNG_DEPSTRUCT; /* user read transform */
+#endif
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+   png_user_transform_ptr write_user_transform_fn PNG_DEPSTRUCT; /* user write transform */
+#endif
+
+/* These were added in libpng-1.0.2 */
+#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+   png_voidp user_transform_ptr PNG_DEPSTRUCT; /* user supplied struct for user transform */
+   png_byte user_transform_depth PNG_DEPSTRUCT;    /* bit depth of user transformed pixels */
+   png_byte user_transform_channels PNG_DEPSTRUCT; /* channels in user transformed pixels */
+#endif
+#endif
+
+   png_uint_32 mode PNG_DEPSTRUCT;          /* tells us where we are in the PNG file */
+   png_uint_32 flags PNG_DEPSTRUCT;         /* flags indicating various things to libpng */
+   png_uint_32 transformations PNG_DEPSTRUCT; /* which transformations to perform */
+
+   z_stream zstream PNG_DEPSTRUCT;          /* pointer to decompression structure (below) */
+   png_bytep zbuf PNG_DEPSTRUCT;            /* buffer for zlib */
+   png_size_t zbuf_size PNG_DEPSTRUCT;      /* size of zbuf */
+   int zlib_level PNG_DEPSTRUCT;            /* holds zlib compression level */
+   int zlib_method PNG_DEPSTRUCT;           /* holds zlib compression method */
+   int zlib_window_bits PNG_DEPSTRUCT;      /* holds zlib compression window bits */
+   int zlib_mem_level PNG_DEPSTRUCT;        /* holds zlib compression memory level */
+   int zlib_strategy PNG_DEPSTRUCT;         /* holds zlib compression strategy */
+
+   png_uint_32 width PNG_DEPSTRUCT;         /* width of image in pixels */
+   png_uint_32 height PNG_DEPSTRUCT;        /* height of image in pixels */
+   png_uint_32 num_rows PNG_DEPSTRUCT;      /* number of rows in current pass */
+   png_uint_32 usr_width PNG_DEPSTRUCT;     /* width of row at start of write */
+   png_size_t rowbytes PNG_DEPSTRUCT;       /* size of row in bytes */
+   png_size_t irowbytes PNG_DEPSTRUCT;      /* size of current interlaced row in bytes */
+   png_uint_32 iwidth PNG_DEPSTRUCT;        /* width of current interlaced row in pixels */
+   png_uint_32 row_number PNG_DEPSTRUCT;    /* current row in interlace pass */
+   png_bytep prev_row PNG_DEPSTRUCT;        /* buffer to save previous (unfiltered) row */
+   png_bytep row_buf PNG_DEPSTRUCT;         /* buffer to save current (unfiltered) row */
+   png_bytep sub_row PNG_DEPSTRUCT;         /* buffer to save "sub" row when filtering */
+   png_bytep up_row PNG_DEPSTRUCT;          /* buffer to save "up" row when filtering */
+   png_bytep avg_row PNG_DEPSTRUCT;         /* buffer to save "avg" row when filtering */
+   png_bytep paeth_row PNG_DEPSTRUCT;       /* buffer to save "Paeth" row when filtering */
+   png_row_info row_info PNG_DEPSTRUCT;     /* used for transformation routines */
+
+   png_uint_32 idat_size PNG_DEPSTRUCT;     /* current IDAT size for read */
+   png_uint_32 crc PNG_DEPSTRUCT;           /* current chunk CRC value */
+   png_colorp palette PNG_DEPSTRUCT;        /* palette from the input file */
+   png_uint_16 num_palette PNG_DEPSTRUCT;   /* number of color entries in palette */
+   png_uint_16 num_trans PNG_DEPSTRUCT;     /* number of transparency values */
+   png_byte chunk_name[5] PNG_DEPSTRUCT;    /* null-terminated name of current chunk */
+   png_byte compression PNG_DEPSTRUCT;      /* file compression type (always 0) */
+   png_byte filter PNG_DEPSTRUCT;           /* file filter type (always 0) */
+   png_byte interlaced PNG_DEPSTRUCT;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
+   png_byte pass PNG_DEPSTRUCT;             /* current interlace pass (0 - 6) */
+   png_byte do_filter PNG_DEPSTRUCT;        /* row filter flags (see PNG_FILTER_ below ) */
+   png_byte color_type PNG_DEPSTRUCT;       /* color type of file */
+   png_byte bit_depth PNG_DEPSTRUCT;        /* bit depth of file */
+   png_byte usr_bit_depth PNG_DEPSTRUCT;    /* bit depth of users row */
+   png_byte pixel_depth PNG_DEPSTRUCT;      /* number of bits per pixel */
+   png_byte channels PNG_DEPSTRUCT;         /* number of channels in file */
+   png_byte usr_channels PNG_DEPSTRUCT;     /* channels at start of write */
+   png_byte sig_bytes PNG_DEPSTRUCT;        /* magic bytes read/written from start of file */
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+   png_uint_16 filler PNG_DEPSTRUCT;           /* filler bytes for pixel expansion */
+#endif
+
+#ifdef PNG_bKGD_SUPPORTED
+   png_byte background_gamma_type PNG_DEPSTRUCT;
+#  ifdef PNG_FLOATING_POINT_SUPPORTED
+   float background_gamma PNG_DEPSTRUCT;
+#  endif
+   png_color_16 background PNG_DEPSTRUCT;   /* background color in screen gamma space */
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   png_color_16 background_1 PNG_DEPSTRUCT; /* background normalized to gamma 1.0 */
+#endif
+#endif /* PNG_bKGD_SUPPORTED */
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+   png_flush_ptr output_flush_fn PNG_DEPSTRUCT; /* Function for flushing output */
+   png_uint_32 flush_dist PNG_DEPSTRUCT;    /* how many rows apart to flush, 0 - no flush */
+   png_uint_32 flush_rows PNG_DEPSTRUCT;    /* number of rows written since last flush */
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   int gamma_shift PNG_DEPSTRUCT;      /* number of "insignificant" bits 16-bit gamma */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   float gamma PNG_DEPSTRUCT;          /* file gamma value */
+   float screen_gamma PNG_DEPSTRUCT;   /* screen gamma value (display_exponent) */
+#endif
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   png_bytep gamma_table PNG_DEPSTRUCT;     /* gamma table for 8-bit depth files */
+   png_bytep gamma_from_1 PNG_DEPSTRUCT;    /* converts from 1.0 to screen */
+   png_bytep gamma_to_1 PNG_DEPSTRUCT;      /* converts from file to 1.0 */
+   png_uint_16pp gamma_16_table PNG_DEPSTRUCT; /* gamma table for 16-bit depth files */
+   png_uint_16pp gamma_16_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to screen */
+   png_uint_16pp gamma_16_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)
+   png_color_8 sig_bit PNG_DEPSTRUCT;       /* significant bits in each available channel */
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+   png_color_8 shift PNG_DEPSTRUCT;         /* shift for significant bit tranformation */
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
+ || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   png_bytep trans_alpha PNG_DEPSTRUCT;           /* alpha values for paletted files */
+   png_color_16 trans_color PNG_DEPSTRUCT;  /* transparent color for non-paletted files */
+#endif
+
+   png_read_status_ptr read_row_fn PNG_DEPSTRUCT;   /* called after each row is decoded */
+   png_write_status_ptr write_row_fn PNG_DEPSTRUCT; /* called after each row is encoded */
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+   png_progressive_info_ptr info_fn PNG_DEPSTRUCT; /* called after header data fully read */
+   png_progressive_row_ptr row_fn PNG_DEPSTRUCT;   /* called after each prog. row is decoded */
+   png_progressive_end_ptr end_fn PNG_DEPSTRUCT;   /* called after image is complete */
+   png_bytep save_buffer_ptr PNG_DEPSTRUCT;        /* current location in save_buffer */
+   png_bytep save_buffer PNG_DEPSTRUCT;            /* buffer for previously read data */
+   png_bytep current_buffer_ptr PNG_DEPSTRUCT;     /* current location in current_buffer */
+   png_bytep current_buffer PNG_DEPSTRUCT;         /* buffer for recently used data */
+   png_uint_32 push_length PNG_DEPSTRUCT;          /* size of current input chunk */
+   png_uint_32 skip_length PNG_DEPSTRUCT;          /* bytes to skip in input data */
+   png_size_t save_buffer_size PNG_DEPSTRUCT;      /* amount of data now in save_buffer */
+   png_size_t save_buffer_max PNG_DEPSTRUCT;       /* total size of save_buffer */
+   png_size_t buffer_size PNG_DEPSTRUCT;           /* total amount of available input data */
+   png_size_t current_buffer_size PNG_DEPSTRUCT;   /* amount of data now in current_buffer */
+   int process_mode PNG_DEPSTRUCT;                 /* what push library is currently doing */
+   int cur_palette PNG_DEPSTRUCT;                  /* current push library palette index */
+
+#  ifdef PNG_TEXT_SUPPORTED
+     png_size_t current_text_size PNG_DEPSTRUCT;   /* current size of text input data */
+     png_size_t current_text_left PNG_DEPSTRUCT;   /* how much text left to read in input */
+     png_charp current_text PNG_DEPSTRUCT;         /* current text chunk buffer */
+     png_charp current_text_ptr PNG_DEPSTRUCT;     /* current location in current_text */
+#  endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */
+
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+/* For the Borland special 64K segment handler */
+   png_bytepp offset_table_ptr PNG_DEPSTRUCT;
+   png_bytep offset_table PNG_DEPSTRUCT;
+   png_uint_16 offset_table_number PNG_DEPSTRUCT;
+   png_uint_16 offset_table_count PNG_DEPSTRUCT;
+   png_uint_16 offset_table_count_free PNG_DEPSTRUCT;
+#endif
+
+#ifdef PNG_READ_DITHER_SUPPORTED
+   png_bytep palette_lookup PNG_DEPSTRUCT;         /* lookup table for dithering */
+   png_bytep dither_index PNG_DEPSTRUCT;           /* index translation for palette files */
+#endif
+
+#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED)
+   png_uint_16p hist PNG_DEPSTRUCT;                /* histogram */
+#endif
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+   png_byte heuristic_method PNG_DEPSTRUCT;        /* heuristic for row filter selection */
+   png_byte num_prev_filters PNG_DEPSTRUCT;        /* number of weights for previous rows */
+   png_bytep prev_filters PNG_DEPSTRUCT;           /* filter type(s) of previous row(s) */
+   png_uint_16p filter_weights PNG_DEPSTRUCT;      /* weight(s) for previous line(s) */
+   png_uint_16p inv_filter_weights PNG_DEPSTRUCT;  /* 1/weight(s) for previous line(s) */
+   png_uint_16p filter_costs PNG_DEPSTRUCT;        /* relative filter calculation cost */
+   png_uint_16p inv_filter_costs PNG_DEPSTRUCT;    /* 1/relative filter calculation cost */
+#endif
+
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+   png_charp time_buffer PNG_DEPSTRUCT;            /* String to hold RFC 1123 time text */
+#endif
+
+/* New members added in libpng-1.0.6 */
+
+   png_uint_32 free_me PNG_DEPSTRUCT;     /* flags items libpng is responsible for freeing */
+
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+   png_voidp user_chunk_ptr PNG_DEPSTRUCT;
+   png_user_chunk_ptr read_user_chunk_fn PNG_DEPSTRUCT; /* user read chunk handler */
+#endif
+
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+   int num_chunk_list PNG_DEPSTRUCT;
+   png_bytep chunk_list PNG_DEPSTRUCT;
+#endif
+
+/* New members added in libpng-1.0.3 */
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+   png_byte rgb_to_gray_status PNG_DEPSTRUCT;
+   /* These were changed from png_byte in libpng-1.0.6 */
+   png_uint_16 rgb_to_gray_red_coeff PNG_DEPSTRUCT;
+   png_uint_16 rgb_to_gray_green_coeff PNG_DEPSTRUCT;
+   png_uint_16 rgb_to_gray_blue_coeff PNG_DEPSTRUCT;
+#endif
+
+/* New member added in libpng-1.0.4 (renamed in 1.0.9) */
+#if defined(PNG_MNG_FEATURES_SUPPORTED) || \
+    defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
+    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
+/* Changed from png_byte to png_uint_32 at version 1.2.0 */
+   png_uint_32 mng_features_permitted PNG_DEPSTRUCT;
+#endif
+
+/* New member added in libpng-1.0.7 */
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   png_fixed_point int_gamma PNG_DEPSTRUCT;
+#endif
+
+/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   png_byte filter_type PNG_DEPSTRUCT;
+#endif
+
+/* New members added in libpng-1.2.0 */
+
+/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_voidp mem_ptr PNG_DEPSTRUCT;                /* user supplied struct for mem functions */
+   png_malloc_ptr malloc_fn PNG_DEPSTRUCT;         /* function for allocating memory */
+   png_free_ptr free_fn PNG_DEPSTRUCT;             /* function for freeing memory */
+#endif
+
+/* New member added in libpng-1.0.13 and 1.2.0 */
+   png_bytep big_row_buf PNG_DEPSTRUCT;         /* buffer to save current (unfiltered) row */
+
+#ifdef PNG_READ_DITHER_SUPPORTED
+/* The following three members were added at version 1.0.14 and 1.2.4 */
+   png_bytep dither_sort PNG_DEPSTRUCT;            /* working sort array */
+   png_bytep index_to_palette PNG_DEPSTRUCT;       /* where the original index currently is */
+                                     /* in the palette */
+   png_bytep palette_to_index PNG_DEPSTRUCT;       /* which original index points to this */
+                                     /* palette color */
+#endif
+
+/* New members added in libpng-1.0.16 and 1.2.6 */
+   png_byte compression_type PNG_DEPSTRUCT;
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   png_uint_32 user_width_max PNG_DEPSTRUCT;
+   png_uint_32 user_height_max PNG_DEPSTRUCT;
+   /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown
+    * chunks that can be stored (0x7fffffff means unlimited).
+    */
+   png_uint_32 user_chunk_cache_max PNG_DEPSTRUCT;
+#endif
+
+/* New member added in libpng-1.0.25 and 1.2.17 */
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+   /* Storage for unknown chunk that the library doesn't recognize. */
+   png_unknown_chunk unknown_chunk PNG_DEPSTRUCT;
+#endif
+
+/* New members added in libpng-1.2.26 */
+  png_uint_32 old_big_row_buf_size PNG_DEPSTRUCT;
+  png_uint_32 old_prev_row_size PNG_DEPSTRUCT;
+
+/* New member added in libpng-1.2.30 */
+  png_charp chunkdata PNG_DEPSTRUCT;  /* buffer for reading chunk data */
+
+/* New member added in libpng-1.4.0 */
+#ifdef PNG_IO_STATE_SUPPORTED
+   png_uint_32 io_state PNG_DEPSTRUCT;
+#endif
+};
+
+
+/* This triggers a compiler error in png.c, if png.c and png.h
+ * do not agree upon the version number.
+ */
+typedef png_structp version_1_4_0;
+
+typedef png_struct FAR * FAR * png_structpp;
+
+/* Here are the function definitions most commonly used.  This is not
+ * the place to find out how to use libpng.  See libpng.txt for the
+ * full explanation, see example.c for the summary.  This just provides
+ * a simple one line description of the use of each function.
+ */
+
+/* Returns the version number of the library */
+extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void));
+
+/* Tell lib we have already handled the first <num_bytes> magic bytes.
+ * Handling more than 8 bytes from the beginning of the file is an error.
+ */
+extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr,
+   int num_bytes));
+
+/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
+ * PNG file.  Returns zero if the supplied bytes match the 8-byte PNG
+ * signature, and non-zero otherwise.  Having num_to_check == 0 or
+ * start > 7 will always fail (ie return non-zero).
+ */
+extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,
+   png_size_t num_to_check));
+
+/* Allocate and initialize png_ptr struct for reading, and any other memory. */
+extern PNG_EXPORT(png_structp,png_create_read_struct)
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;
+
+/* Allocate and initialize png_ptr struct for writing, and any other memory */
+extern PNG_EXPORT(png_structp,png_create_write_struct)
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;
+
+#ifdef PNG_WRITE_SUPPORTED
+extern PNG_EXPORT(png_size_t,png_get_compression_buffer_size)
+   PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+extern PNG_EXPORT(void,png_set_compression_buffer_size)
+   PNGARG((png_structp png_ptr, png_size_t size));
+#endif
+
+/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
+ * match up.
+ */
+#ifdef PNG_SETJMP_SUPPORTED
+/* This function returns the jmp_buf built in to *png_ptr.  It must be
+ * supplied with an appropriate 'longjmp' function to use on that jmp_buf
+ * unless the default error function is overridden in which case NULL is
+ * acceptable.  The size of the jmp_buf is checked against the actual size
+ * allocated by the library - the call will return NULL on a mismatch
+ * indicating an ABI mismatch.
+ */
+extern PNG_EXPORT(jmp_buf*, png_set_longjmp_fn)
+   PNGARG((png_structp png_ptr, png_longjmp_ptr longjmp_fn, size_t jmp_buf_size));
+#  define png_jmpbuf(png_ptr) \
+   (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf)))
+#else
+#  define png_jmpbuf(png_ptr) \
+   (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
+#endif
+
+/* Reset the compression stream */
+extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr));
+
+/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
+#ifdef PNG_USER_MEM_SUPPORTED
+extern PNG_EXPORT(png_structp,png_create_read_struct_2)
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;
+extern PNG_EXPORT(png_structp,png_create_write_struct_2)
+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;
+#endif
+
+/* Write the PNG file signature. */
+extern PNG_EXPORT(void,png_write_sig) PNGARG((png_structp png_ptr));
+
+/* Write a PNG chunk - size, type, (optional) data, CRC. */
+extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,
+   png_bytep chunk_name, png_bytep data, png_size_t length));
+
+/* Write the start of a PNG chunk - length and chunk name. */
+extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr,
+   png_bytep chunk_name, png_uint_32 length));
+
+/* Write the data of a PNG chunk started with png_write_chunk_start(). */
+extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr,
+   png_bytep data, png_size_t length));
+
+/* Finish a chunk started with png_write_chunk_start() (includes CRC). */
+extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));
+
+/* Allocate and initialize the info structure */
+extern PNG_EXPORT(png_infop,png_create_info_struct)
+   PNGARG((png_structp png_ptr)) PNG_ALLOCATED;
+
+extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr,
+    png_size_t png_info_struct_size));
+
+/* Writes all the PNG information before the image. */
+extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr,
+   png_infop info_ptr));
+extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,
+   png_infop info_ptr));
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the information before the actual image data. */
+extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,
+   png_infop info_ptr));
+#endif
+
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)
+   PNGARG((png_structp png_ptr, png_timep ptime));
+#endif
+
+#ifdef PNG_CONVERT_tIME_SUPPORTED
+/* Convert from a struct tm to png_time */
+extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,
+   struct tm FAR * ttime));
+
+/* Convert from time_t to png_time.  Uses gmtime() */
+extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime,
+   time_t ttime));
+#endif /* PNG_CONVERT_tIME_SUPPORTED */
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
+extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp
+  png_ptr));
+extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* Use blue, green, red order for pixels. */
+extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+/* Expand the grayscale to 24-bit RGB if necessary. */
+extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+/* Reduce RGB to grayscale. */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr,
+   int error_action, double red, double green ));
+#endif
+extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr,
+   int error_action, png_fixed_point red, png_fixed_point green ));
+extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp
+   png_ptr));
+#endif
+
+extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth,
+   png_colorp palette));
+
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */
+extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr,
+   png_uint_32 filler, int flags));
+/* The values of the PNG_FILLER_ defines should NOT be changed */
+#define PNG_FILLER_BEFORE 0
+#define PNG_FILLER_AFTER 1
+/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
+extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr,
+   png_uint_32 filler, int flags));
+#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* Swap bytes in 16-bit depth files. */
+extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
+extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+/* Swap packing order of pixels in bytes. */
+extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+/* Converts files to legal bit depths. */
+extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr,
+   png_color_8p true_bits));
+#endif
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+    defined(PNG_WRITE_INTERLACING_SUPPORTED)
+/* Have the code handle the interlacing.  Returns the number of passes. */
+extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+/* Invert monochrome files */
+extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+/* Handle alpha and tRNS by replacing with a background color. */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,
+   png_color_16p background_color, int background_gamma_code,
+   int need_expand, double background_gamma));
+#endif
+#define PNG_BACKGROUND_GAMMA_UNKNOWN 0
+#define PNG_BACKGROUND_GAMMA_SCREEN  1
+#define PNG_BACKGROUND_GAMMA_FILE    2
+#define PNG_BACKGROUND_GAMMA_UNIQUE  3
+#endif
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+/* Strip the second byte of information from a 16-bit depth file. */
+extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_READ_DITHER_SUPPORTED
+/* Turn on dithering, and reduce the palette to the number of colors available. */
+extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr,
+   png_colorp palette, int num_palette, int maximum_colors,
+   png_uint_16p histogram, int full_dither));
+#endif
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+/* Handle gamma correction. Screen_gamma=(display_exponent) */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr,
+   double screen_gamma, double default_file_gamma));
+#endif
+#endif
+
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+/* Set how many lines between output flushes - 0 for no flushing */
+extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows));
+/* Flush the current PNG output buffer */
+extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr));
+#endif
+
+/* Optional update palette with requested transformations */
+extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr));
+
+/* Optional call to update the users info structure */
+extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr,
+   png_infop info_ptr));
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read one or more rows of image data. */
+extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr,
+   png_bytepp row, png_bytepp display_row, png_uint_32 num_rows));
+#endif
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read a row of data. */
+extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr,
+   png_bytep row,
+   png_bytep display_row));
+#endif
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the whole image into memory at once. */
+extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr,
+   png_bytepp image));
+#endif
+
+/* Write a row of image data */
+extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr,
+   png_bytep row));
+
+/* Write a few rows of image data */
+extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr,
+   png_bytepp row, png_uint_32 num_rows));
+
+/* Write the image data */
+extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr,
+   png_bytepp image));
+
+/* Write the end of the PNG file. */
+extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr,
+   png_infop info_ptr));
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the end of the PNG file. */
+extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr,
+   png_infop info_ptr));
+#endif
+
+/* Free any memory associated with the png_info_struct */
+extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr,
+   png_infopp info_ptr_ptr));
+
+/* Free any memory associated with the png_struct and the png_info_structs */
+extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp
+   png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));
+
+/* Free any memory associated with the png_struct and the png_info_structs */
+extern PNG_EXPORT(void,png_destroy_write_struct)
+   PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));
+
+/* Set the libpng method of handling chunk CRC errors */
+extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,
+   int crit_action, int ancil_action));
+
+/* Values for png_set_crc_action() to say how to handle CRC errors in
+ * ancillary and critical chunks, and whether to use the data contained
+ * therein.  Note that it is impossible to "discard" data in a critical
+ * chunk.  For versions prior to 0.90, the action was always error/quit,
+ * whereas in version 0.90 and later, the action for CRC errors in ancillary
+ * chunks is warn/discard.  These values should NOT be changed.
+ *
+ *      value                       action:critical     action:ancillary
+ */
+#define PNG_CRC_DEFAULT       0  /* error/quit          warn/discard data */
+#define PNG_CRC_ERROR_QUIT    1  /* error/quit          error/quit        */
+#define PNG_CRC_WARN_DISCARD  2  /* (INVALID)           warn/discard data */
+#define PNG_CRC_WARN_USE      3  /* warn/use data       warn/use data     */
+#define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */
+#define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */
+
+/* These functions give the user control over the scan-line filtering in
+ * libpng and the compression methods used by zlib.  These functions are
+ * mainly useful for testing, as the defaults should work with most users.
+ * Those users who are tight on memory or want faster performance at the
+ * expense of compression can modify them.  See the compression library
+ * header file (zlib.h) for an explination of the compression functions.
+ */
+
+/* Set the filtering method(s) used by libpng.  Currently, the only valid
+ * value for "method" is 0.
+ */
+extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,
+   int filters));
+
+/* Flags for png_set_filter() to say which filters to use.  The flags
+ * are chosen so that they don't conflict with real filter types
+ * below, in case they are supplied instead of the #defined constants.
+ * These values should NOT be changed.
+ */
+#define PNG_NO_FILTERS     0x00
+#define PNG_FILTER_NONE    0x08
+#define PNG_FILTER_SUB     0x10
+#define PNG_FILTER_UP      0x20
+#define PNG_FILTER_AVG     0x40
+#define PNG_FILTER_PAETH   0x80
+#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \
+                         PNG_FILTER_AVG | PNG_FILTER_PAETH)
+
+/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
+ * These defines should NOT be changed.
+ */
+#define PNG_FILTER_VALUE_NONE  0
+#define PNG_FILTER_VALUE_SUB   1
+#define PNG_FILTER_VALUE_UP    2
+#define PNG_FILTER_VALUE_AVG   3
+#define PNG_FILTER_VALUE_PAETH 4
+#define PNG_FILTER_VALUE_LAST  5
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */
+/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_
+ * defines, either the default (minimum-sum-of-absolute-differences), or
+ * the experimental method (weighted-minimum-sum-of-absolute-differences).
+ *
+ * Weights are factors >= 1.0, indicating how important it is to keep the
+ * filter type consistent between rows.  Larger numbers mean the current
+ * filter is that many times as likely to be the same as the "num_weights"
+ * previous filters.  This is cumulative for each previous row with a weight.
+ * There needs to be "num_weights" values in "filter_weights", or it can be
+ * NULL if the weights aren't being specified.  Weights have no influence on
+ * the selection of the first row filter.  Well chosen weights can (in theory)
+ * improve the compression for a given image.
+ *
+ * Costs are factors >= 1.0 indicating the relative decoding costs of a
+ * filter type.  Higher costs indicate more decoding expense, and are
+ * therefore less likely to be selected over a filter with lower computational
+ * costs.  There needs to be a value in "filter_costs" for each valid filter
+ * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't
+ * setting the costs.  Costs try to improve the speed of decompression without
+ * unduly increasing the compressed image size.
+ *
+ * A negative weight or cost indicates the default value is to be used, and
+ * values in the range [0.0, 1.0) indicate the value is to remain unchanged.
+ * The default values for both weights and costs are currently 1.0, but may
+ * change if good general weighting/cost heuristics can be found.  If both
+ * the weights and costs are set to 1.0, this degenerates the WEIGHTED method
+ * to the UNWEIGHTED method, but with added encoding time/computation.
+ */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr,
+   int heuristic_method, int num_weights, png_doublep filter_weights,
+   png_doublep filter_costs));
+#endif
+#endif /*  PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
+
+/* Heuristic used for row filter selection.  These defines should NOT be
+ * changed.
+ */
+#define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */
+#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */
+#define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */
+#define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */
+
+/* Set the library compression level.  Currently, valid values range from
+ * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
+ * (0 - no compression, 9 - "maximal" compression).  Note that tests have
+ * shown that zlib compression levels 3-6 usually perform as well as level 9
+ * for PNG images, and do considerably fewer caclulations.  In the future,
+ * these values may not correspond directly to the zlib compression levels.
+ */
+extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr,
+   int level));
+
+extern PNG_EXPORT(void,png_set_compression_mem_level)
+   PNGARG((png_structp png_ptr, int mem_level));
+
+extern PNG_EXPORT(void,png_set_compression_strategy)
+   PNGARG((png_structp png_ptr, int strategy));
+
+extern PNG_EXPORT(void,png_set_compression_window_bits)
+   PNGARG((png_structp png_ptr, int window_bits));
+
+extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,
+   int method));
+
+/* These next functions are called for input/output, memory, and error
+ * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,
+ * and call standard C I/O routines such as fread(), fwrite(), and
+ * fprintf().  These functions can be made to use other I/O routines
+ * at run time for those applications that need to handle I/O in a
+ * different manner by calling png_set_???_fn().  See libpng.txt for
+ * more information.
+ */
+
+#ifdef PNG_STDIO_SUPPORTED
+/* Initialize the input/output for the PNG file to the default functions. */
+extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp));
+#endif
+
+/* Replace the (error and abort), and warning functions with user
+ * supplied functions.  If no messages are to be printed you must still
+ * write and use replacement functions. The replacement error_fn should
+ * still do a longjmp to the last setjmp location if you are using this
+ * method of error handling.  If error_fn or warning_fn is NULL, the
+ * default function will be used.
+ */
+
+extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr,
+   png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
+
+/* Return the user pointer associated with the error functions */
+extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));
+
+/* Replace the default data output functions with a user supplied one(s).
+ * If buffered output is not used, then output_flush_fn can be set to NULL.
+ * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
+ * output_flush_fn will be ignored (and thus can be NULL).
+ * It is probably a mistake to use NULL for output_flush_fn if
+ * write_data_fn is not also NULL unless you have built libpng with
+ * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's
+ * default flush function, which uses the standard *FILE structure, will
+ * be used.
+ */
+extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,
+   png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
+
+/* Replace the default data input function with a user supplied one. */
+extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,
+   png_voidp io_ptr, png_rw_ptr read_data_fn));
+
+/* Return the user pointer associated with the I/O functions */
+extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));
+
+extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,
+   png_read_status_ptr read_row_fn));
+
+extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,
+   png_write_status_ptr write_row_fn));
+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* Replace the default memory allocation functions with user supplied one(s). */
+extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,
+   png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+/* Return the user pointer associated with the memory functions */
+extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp
+   png_ptr, png_user_transform_ptr read_user_transform_fn));
+#endif
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp
+   png_ptr, png_user_transform_ptr write_user_transform_fn));
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp
+   png_ptr, png_voidp user_transform_ptr, int user_transform_depth,
+   int user_transform_channels));
+/* Return the user pointer associated with the user transform functions */
+extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr)
+   PNGARG((png_structp png_ptr));
+#endif
+
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,
+   png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
+extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp
+   png_ptr));
+#endif
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+/* Sets the function callbacks for the push reader, and a pointer to a
+ * user-defined structure available to the callback functions.
+ */
+extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr,
+   png_voidp progressive_ptr,
+   png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
+   png_progressive_end_ptr end_fn));
+
+/* Returns the user pointer associated with the push read functions */
+extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)
+   PNGARG((png_structp png_ptr));
+
+/* Function to be called when data becomes available */
+extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));
+
+/* Function that combines rows.  Not very much different than the
+ * png_combine_row() call.  Is this even used?????
+ */
+extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,
+   png_bytep old_row, png_bytep new_row));
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,
+   png_alloc_size_t size)) PNG_ALLOCATED;
+/* Added at libpng version 1.4.0 */
+extern PNG_EXPORT(png_voidp,png_calloc) PNGARG((png_structp png_ptr,
+   png_alloc_size_t size)) PNG_ALLOCATED;
+
+/* Added at libpng version 1.2.4 */
+extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr,
+   png_alloc_size_t size)) PNG_ALLOCATED;
+
+/* Frees a pointer allocated by png_malloc() */
+extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));
+
+/* Free data that was allocated internally */
+extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_uint_32 free_me, int num));
+/* Reassign responsibility for freeing existing data, whether allocated
+ * by libpng or by the application */
+extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int freer, png_uint_32 mask));
+/* Assignments for png_data_freer */
+#define PNG_DESTROY_WILL_FREE_DATA 1
+#define PNG_SET_WILL_FREE_DATA 1
+#define PNG_USER_WILL_FREE_DATA 2
+/* Flags for png_ptr->free_me and info_ptr->free_me */
+#define PNG_FREE_HIST 0x0008
+#define PNG_FREE_ICCP 0x0010
+#define PNG_FREE_SPLT 0x0020
+#define PNG_FREE_ROWS 0x0040
+#define PNG_FREE_PCAL 0x0080
+#define PNG_FREE_SCAL 0x0100
+#define PNG_FREE_UNKN 0x0200
+#define PNG_FREE_LIST 0x0400
+#define PNG_FREE_PLTE 0x1000
+#define PNG_FREE_TRNS 0x2000
+#define PNG_FREE_TEXT 0x4000
+#define PNG_FREE_ALL  0x7fff
+#define PNG_FREE_MUL  0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
+
+#ifdef PNG_USER_MEM_SUPPORTED
+extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,
+   png_alloc_size_t size)) PNG_ALLOCATED;
+extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,
+   png_voidp ptr));
+#endif
+
+#ifndef PNG_NO_ERROR_TEXT
+/* Fatal error in PNG image of libpng - can't continue */
+extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,
+   png_const_charp error_message)) PNG_NORETURN;
+
+/* The same, but the chunk name is prepended to the error string. */
+extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,
+   png_const_charp error_message)) PNG_NORETURN;
+
+#else
+/* Fatal error in PNG image of libpng - can't continue */
+extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr)) PNG_NORETURN;
+#endif
+
+/* Non-fatal error in libpng.  Can continue, but may have a problem. */
+extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,
+   png_const_charp warning_message));
+
+/* Non-fatal error in libpng, chunk name is prepended to message. */
+extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,
+   png_const_charp warning_message));
+
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+/* Benign error in libpng.  Can continue, but may have a problem.
+ * User can choose whether to handle as a fatal error or as a warning. */
+extern PNG_EXPORT(void,png_benign_error) PNGARG((png_structp png_ptr,
+   png_const_charp warning_message));
+
+/* Same, chunk name is prepended to message. */
+extern PNG_EXPORT(void,png_chunk_benign_error) PNGARG((png_structp png_ptr,
+   png_const_charp warning_message));
+
+extern PNG_EXPORT(void,png_set_benign_errors) PNGARG((png_structp
+   png_ptr, int allowed));
+#endif
+
+/* The png_set_<chunk> functions are for storing values in the png_info_struct.
+ * Similarly, the png_get_<chunk> calls are used to read values from the
+ * png_info_struct, either storing the parameters in the passed variables, or
+ * setting pointers into the png_info_struct where the data is stored.  The
+ * png_get_<chunk> functions return a non-zero value if the data was available
+ * in info_ptr, or return zero and do not change any of the parameters if the
+ * data was not available.
+ *
+ * These functions should be used instead of directly accessing png_info
+ * to avoid problems with future changes in the size and internal layout of
+ * png_info_struct.
+ */
+/* Returns "flag" if chunk data is valid in info_ptr. */
+extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,
+png_infop info_ptr, png_uint_32 flag));
+
+/* Returns number of bytes needed to hold a transformed row. */
+extern PNG_EXPORT(png_size_t,png_get_rowbytes) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+/* Returns row_pointers, which is an array of pointers to scanlines that was
+ * returned from png_read_png().
+ */
+extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+/* Set row_pointers, which is an array of pointers to scanlines for use
+ * by png_write_png().
+ */
+extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_bytepp row_pointers));
+#endif
+
+/* Returns number of color channels in image. */
+extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* Returns image width in pixels. */
+extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image height in pixels. */
+extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image bit_depth. */
+extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image color_type. */
+extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image filter_type. */
+extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image interlace_type. */
+extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image compression_type. */
+extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns image resolution in pixels per meter, from pHYs chunk data. */
+extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+/* Returns pixel aspect ratio, computed from pHYs chunk data.  */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+#endif
+
+/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
+extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp
+png_ptr, png_infop info_ptr));
+
+#endif /* PNG_EASY_ACCESS_SUPPORTED */
+
+/* Returns pointer to signature string read from PNG header */
+extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#ifdef PNG_bKGD_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_color_16p *background));
+#endif
+
+#ifdef PNG_bKGD_SUPPORTED
+extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_color_16p background));
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, double *white_x, double *white_y, double *red_x,
+   double *red_y, double *green_x, double *green_y, double *blue_x,
+   double *blue_y));
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point
+   *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,
+   png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point
+   *int_blue_x, png_fixed_point *int_blue_y));
+#endif
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, double white_x, double white_y, double red_x,
+   double red_y, double green_x, double green_y, double blue_x, double blue_y));
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,
+   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
+   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
+   png_fixed_point int_blue_y));
+#endif
+#endif
+
+#ifdef PNG_gAMA_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, double *file_gamma));
+#endif
+extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_fixed_point *int_file_gamma));
+#endif
+
+#ifdef PNG_gAMA_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, double file_gamma));
+#endif
+extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_fixed_point int_file_gamma));
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_uint_16p *hist));
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_uint_16p hist));
+#endif
+
+extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,
+   int *bit_depth, int *color_type, int *interlace_method,
+   int *compression_method, int *filter_method));
+
+extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,
+   int color_type, int interlace_method, int compression_method,
+   int filter_method));
+
+#ifdef PNG_oFFs_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
+   int *unit_type));
+#endif
+
+#ifdef PNG_oFFs_SUPPORTED
+extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,
+   int unit_type));
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,
+   int *type, int *nparams, png_charp *units, png_charpp *params));
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,
+   int type, int nparams, png_charp units, png_charpp params));
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
+#endif
+
+extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_colorp *palette, int *num_palette));
+
+extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_colorp palette, int num_palette));
+
+#ifdef PNG_sBIT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_color_8p *sig_bit));
+#endif
+
+#ifdef PNG_sBIT_SUPPORTED
+extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_color_8p sig_bit));
+#endif
+
+#ifdef PNG_sRGB_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int *intent));
+#endif
+
+#ifdef PNG_sRGB_SUPPORTED
+extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int intent));
+extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int intent));
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_charpp name, int *compression_type,
+   png_charpp profile, png_uint_32 *proflen));
+   /* Note to maintainer: profile should be png_bytepp */
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_charp name, int compression_type,
+   png_charp profile, png_uint_32 proflen));
+   /* Note to maintainer: profile should be png_bytep */
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_sPLT_tpp entries));
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_sPLT_tp entries, int nentries));
+#endif
+
+#ifdef PNG_TEXT_SUPPORTED
+/* png_get_text also returns the number of text chunks in *num_text */
+extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_textp *text_ptr, int *num_text));
+#endif
+
+/* Note while png_set_text() will accept a structure whose text,
+ * language, and  translated keywords are NULL pointers, the structure
+ * returned by png_get_text will always contain regular
+ * zero-terminated C strings.  They might be empty strings but
+ * they will never be NULL pointers.
+ */
+
+#ifdef PNG_TEXT_SUPPORTED
+extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_textp text_ptr, int num_text));
+#endif
+
+#ifdef PNG_tIME_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_timep *mod_time));
+#endif
+
+#ifdef PNG_tIME_SUPPORTED
+extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_timep mod_time));
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_bytep *trans_alpha, int *num_trans,
+   png_color_16p *trans_color));
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_bytep trans_alpha, int num_trans,
+   png_color_16p trans_color));
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+#endif
+
+#ifdef PNG_sCAL_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int *unit, double *width, double *height));
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));
+#endif
+#endif
+#endif /* PNG_sCAL_SUPPORTED */
+
+#ifdef PNG_sCAL_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int unit, double width, double height));
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));
+#endif
+#endif
+#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */
+
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+/* Provide a list of chunks and how they are to be handled, if the built-in
+   handling or default unknown chunk handling is not desired.  Any chunks not
+   listed will be handled in the default manner.  The IHDR and IEND chunks
+   must not be listed.
+      keep = 0: follow default behaviour
+           = 1: do not keep
+           = 2: keep only if safe-to-copy
+           = 3: keep even if unsafe-to-copy
+*/
+extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp
+   png_ptr, int keep, png_bytep chunk_list, int num_chunks));
+PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep
+   chunk_name));
+#endif
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));
+extern PNG_EXPORT(void, png_set_unknown_chunk_location)
+   PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));
+extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp
+   png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));
+#endif
+
+/* Png_free_data() will turn off the "valid" flag for anything it frees.
+ * If you need to turn it off for a chunk that your application has freed,
+ * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);
+ */
+extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,
+   png_infop info_ptr, int mask));
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+/* The "params" pointer is currently not used and is for future expansion. */
+extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,
+                        png_infop info_ptr,
+                        int transforms,
+                        png_voidp params));
+extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,
+                        png_infop info_ptr,
+                        int transforms,
+                        png_voidp params));
+#endif
+
+extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr));
+extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp
+   png_ptr, png_uint_32 mng_features_permitted));
+#endif
+
+/* For use in png_set_keep_unknown, added to version 1.2.6 */
+#define PNG_HANDLE_CHUNK_AS_DEFAULT   0
+#define PNG_HANDLE_CHUNK_NEVER        1
+#define PNG_HANDLE_CHUNK_IF_SAFE      2
+#define PNG_HANDLE_CHUNK_ALWAYS       3
+
+/* Strip the prepended error numbers ("#nnn ") from error and warning
+ * messages before passing them to the error or warning handler.
+ */
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp
+   png_ptr, png_uint_32 strip_mode));
+#endif
+
+/* Added in libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp
+   png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));
+extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp
+   png_ptr));
+extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp
+   png_ptr));
+/* Added in libpng-1.4.0 */
+extern PNG_EXPORT(void,png_set_chunk_cache_max) PNGARG((png_structp
+   png_ptr, png_uint_32 user_chunk_cache_max));
+extern PNG_EXPORT(png_uint_32,png_get_chunk_cache_max)
+   PNGARG((png_structp png_ptr));
+#endif
+
+#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
+PNG_EXPORT(png_uint_32,png_get_pixels_per_inch) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXPORT(png_uint_32,png_get_x_pixels_per_inch) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXPORT(png_uint_32,png_get_y_pixels_per_inch) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXPORT(float,png_get_x_offset_inches) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+PNG_EXPORT(float,png_get_y_offset_inches) PNGARG((png_structp png_ptr,
+png_infop info_ptr));
+
+#ifdef PNG_pHYs_SUPPORTED
+PNG_EXPORT(png_uint_32,png_get_pHYs_dpi) PNGARG((png_structp png_ptr,
+png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
+#endif /* PNG_pHYs_SUPPORTED */
+#endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
+
+/* Added in libpng-1.4.0 */
+#ifdef PNG_IO_STATE_SUPPORTED
+extern PNG_EXPORT(png_uint_32,png_get_io_state) PNGARG((png_structp png_ptr));
+
+extern PNG_EXPORT(png_bytep,png_get_io_chunk_name)
+   PNGARG((png_structp png_ptr));
+
+/* The flags returned by png_get_io_state() are the following: */
+#define PNG_IO_NONE        0x0000   /* no I/O at this moment */
+#define PNG_IO_READING     0x0001   /* currently reading */
+#define PNG_IO_WRITING     0x0002   /* currently writing */
+#define PNG_IO_SIGNATURE   0x0010   /* currently at the file signature */
+#define PNG_IO_CHUNK_HDR   0x0020   /* currently at the chunk header */
+#define PNG_IO_CHUNK_DATA  0x0040   /* currently at the chunk data */
+#define PNG_IO_CHUNK_CRC   0x0080   /* currently at the chunk crc */
+#define PNG_IO_MASK_OP     0x000f   /* current operation: reading/writing */
+#define PNG_IO_MASK_LOC    0x00f0   /* current location: sig/hdr/data/crc */
+#endif /* ?PNG_IO_STATE_SUPPORTED */
+
+/* Maintainer: Put new public prototypes here ^, in libpng.3, and project
+ * defs
+ */
+
+#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
+/* With these routines we avoid an integer divide, which will be slower on
+ * most machines.  However, it does take more operations than the corresponding
+ * divide method, so it may be slower on a few RISC systems.  There are two
+ * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
+ *
+ * Note that the rounding factors are NOT supposed to be the same!  128 and
+ * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
+ * standard method.
+ *
+ * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
+ */
+
+ /* fg and bg should be in `gamma 1.0' space; alpha is the opacity          */
+
+#  define png_composite(composite, fg, alpha, bg)                            \
+     { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \
+                        +        (png_uint_16)(bg)*(png_uint_16)(255 -       \
+                        (png_uint_16)(alpha)) + (png_uint_16)128);           \
+       (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
+
+#  define png_composite_16(composite, fg, alpha, bg)                         \
+     { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \
+                        + (png_uint_32)(bg)*(png_uint_32)(65535L -           \
+                        (png_uint_32)(alpha)) + (png_uint_32)32768L);        \
+       (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
+
+#else  /* Standard method using integer division */
+
+#  define png_composite(composite, fg, alpha, bg)                            \
+     (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) +    \
+       (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) +       \
+       (png_uint_16)127) / 255)
+
+#  define png_composite_16(composite, fg, alpha, bg)                         \
+     (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
+       (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) +      \
+       (png_uint_32)32767) / (png_uint_32)65535L)
+#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */
+
+#ifdef PNG_USE_READ_MACROS
+/* Inline macros to do direct reads of bytes from the input buffer.
+ * The png_get_int_32() routine assumes we are using two's complement
+ * format for negative values, which is almost certainly true.
+ */
+/* We could make special-case BIG_ENDIAN macros that do direct reads here */
+#  define png_get_uint_32(buf) \
+     (((png_uint_32)(*(buf)) << 24) + \
+      ((png_uint_32)(*((buf) + 1)) << 16) + \
+      ((png_uint_32)(*((buf) + 2)) << 8) + \
+      ((png_uint_32)(*((buf) + 3))))
+#  define png_get_uint_16(buf) \
+     (((png_uint_32)(*(buf)) << 8) + \
+      ((png_uint_32)(*((buf) + 1))))
+#ifdef PNG_GET_INT_32_SUPPORTED
+#  define png_get_int_32(buf) \
+     (((png_int_32)(*(buf)) << 24) + \
+      ((png_int_32)(*((buf) + 1)) << 16) + \
+      ((png_int_32)(*((buf) + 2)) << 8) + \
+      ((png_int_32)(*((buf) + 3))))
+#endif
+#else
+extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf));
+extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf));
+#ifdef PNG_GET_INT_32_SUPPORTED
+extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf));
+#endif
+#endif
+extern PNG_EXPORT(png_uint_32,png_get_uint_31)
+  PNGARG((png_structp png_ptr, png_bytep buf));
+/* No png_get_int_16 -- may be added if there's a real need for it. */
+
+/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */
+extern PNG_EXPORT(void,png_save_uint_32)
+   PNGARG((png_bytep buf, png_uint_32 i));
+extern PNG_EXPORT(void,png_save_int_32)
+   PNGARG((png_bytep buf, png_int_32 i));
+
+/* Place a 16-bit number into a buffer in PNG byte order.
+ * The parameter is declared unsigned int, not png_uint_16,
+ * just to avoid potential problems on pre-ANSI C compilers.
+ */
+extern PNG_EXPORT(void,png_save_uint_16)
+   PNGARG((png_bytep buf, unsigned int i));
+/* No png_save_int_16 -- may be added if there's a real need for it. */
+
+/* ************************************************************************* */
+
+/* Various modes of operation.  Note that after an init, mode is set to
+ * zero automatically when the structure is created.
+ */
+#define PNG_HAVE_IHDR               0x01
+#define PNG_HAVE_PLTE               0x02
+#define PNG_HAVE_IDAT               0x04
+#define PNG_AFTER_IDAT              0x08 /* Have complete zlib datastream */
+#define PNG_HAVE_IEND               0x10
+#define PNG_HAVE_gAMA               0x20
+#define PNG_HAVE_cHRM               0x40
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PNG_VERSION_INFO_ONLY */
+/* Do not put anything past this line */
+#endif /* PNG_H */
diff --git a/src/libpng/pngconf.h b/src/libpng/pngconf.h
index 5cec7bbd4..3570fbedd 100644
--- a/src/libpng/pngconf.h
+++ b/src/libpng/pngconf.h
@@ -1,1658 +1,1482 @@
-

-/* pngconf.h - machine configurable file for libpng

- *

- * libpng version 1.2.41 - December 3, 2009

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- */

-

-/* Any machine specific code is near the front of this file, so if you

- * are configuring libpng for a machine, you may want to read the section

- * starting here down to where it starts to typedef png_color, png_text,

- * and png_info.

- */

-

-#ifndef PNGCONF_H

-#define PNGCONF_H

-

-#define PNG_1_2_X

-

-/*

- * PNG_USER_CONFIG has to be defined on the compiler command line. This

- * includes the resource compiler for Windows DLL configurations.

- */

-#ifdef PNG_USER_CONFIG

-#  ifndef PNG_USER_PRIVATEBUILD

-#    define PNG_USER_PRIVATEBUILD

-#  endif

-#include "pngusr.h"

-#endif

-

-/* PNG_CONFIGURE_LIBPNG is set by the "configure" script. */

-#ifdef PNG_CONFIGURE_LIBPNG

-#ifdef HAVE_CONFIG_H

-#include "config.h"

-#endif

-#endif

-

-/*

- * Added at libpng-1.2.8

- *

- * If you create a private DLL you need to define in "pngusr.h" the followings:

- * #define PNG_USER_PRIVATEBUILD <Describes by whom and why this version of

- *        the DLL was built>

- *  e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons."

- * #define PNG_USER_DLLFNAME_POSTFIX <two-letter postfix that serve to

- *        distinguish your DLL from those of the official release. These

- *        correspond to the trailing letters that come after the version

- *        number and must match your private DLL name>

- *  e.g. // private DLL "libpng13gx.dll"

- *       #define PNG_USER_DLLFNAME_POSTFIX "gx"

- *

- * The following macros are also at your disposal if you want to complete the

- * DLL VERSIONINFO structure.

- * - PNG_USER_VERSIONINFO_COMMENTS

- * - PNG_USER_VERSIONINFO_COMPANYNAME

- * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS

- */

-

-#ifdef __STDC__

-#ifdef SPECIALBUILD

-#  pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\

- are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.")

-#endif

-

-#ifdef PRIVATEBUILD

-# pragma message("PRIVATEBUILD is deprecated.\

- Use PNG_USER_PRIVATEBUILD instead.")

-# define PNG_USER_PRIVATEBUILD PRIVATEBUILD

-#endif

-#endif /* __STDC__ */

-

-#ifndef PNG_VERSION_INFO_ONLY

-

-/* End of material added to libpng-1.2.8 */

-

-/* Added at libpng-1.2.19, removed at libpng-1.2.20 because it caused trouble

-   Restored at libpng-1.2.21 */

-#if !defined(PNG_NO_WARN_UNINITIALIZED_ROW) && \

-    !defined(PNG_WARN_UNINITIALIZED_ROW)

-#  define PNG_WARN_UNINITIALIZED_ROW 1

-#endif

-/* End of material added at libpng-1.2.19/1.2.21 */

-

-/* This is the size of the compression buffer, and thus the size of

- * an IDAT chunk.  Make this whatever size you feel is best for your

- * machine.  One of these will be allocated per png_struct.  When this

- * is full, it writes the data to the disk, and does some other

- * calculations.  Making this an extremely small size will slow

- * the library down, but you may want to experiment to determine

- * where it becomes significant, if you are concerned with memory

- * usage.  Note that zlib allocates at least 32Kb also.  For readers,

- * this describes the size of the buffer available to read the data in.

- * Unless this gets smaller than the size of a row (compressed),

- * it should not make much difference how big this is.

- */

-

-#ifndef PNG_ZBUF_SIZE

-#  define PNG_ZBUF_SIZE 8192

-#endif

-

-/* Enable if you want a write-only libpng */

-

-#ifndef PNG_NO_READ_SUPPORTED

-#  define PNG_READ_SUPPORTED

-#endif

-

-/* Enable if you want a read-only libpng */

-

-#ifndef PNG_NO_WRITE_SUPPORTED

-#  define PNG_WRITE_SUPPORTED

-#endif

-

-/* Enabled in 1.2.41. */

-#ifdef PNG_ALLOW_BENIGN_ERRORS

-#  define png_benign_error png_warning

-#  define png_chunk_benign_error png_chunk_warning

-#else

-#  ifndef PNG_BENIGN_ERRORS_SUPPORTED

-#    define png_benign_error png_error

-#    define png_chunk_benign_error png_chunk_error

-#  endif

-#endif

-

-/* Added in libpng-1.2.41 */

-#if !defined(PNG_NO_WARNINGS) && !defined(PNG_WARNINGS_SUPPORTED)

-#  define PNG_WARNINGS_SUPPORTED

-#endif

-

-#if !defined(PNG_NO_ERROR_TEXT) && !defined(PNG_ERROR_TEXT_SUPPORTED)

-#  define PNG_ERROR_TEXT_SUPPORTED

-#endif

-

-#if !defined(PNG_NO_CHECK_cHRM) && !defined(PNG_CHECK_cHRM_SUPPORTED)

-#  define PNG_CHECK_cHRM_SUPPORTED

-#endif

-

-/* Enabled by default in 1.2.0.  You can disable this if you don't need to

- * support PNGs that are embedded in MNG datastreams

- */

-#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES)

-#  ifndef PNG_MNG_FEATURES_SUPPORTED

-#    define PNG_MNG_FEATURES_SUPPORTED

-#  endif

-#endif

-

-#ifndef PNG_NO_FLOATING_POINT_SUPPORTED

-#  ifndef PNG_FLOATING_POINT_SUPPORTED

-#    define PNG_FLOATING_POINT_SUPPORTED

-#  endif

-#endif

-

-/* If you are running on a machine where you cannot allocate more

- * than 64K of memory at once, uncomment this.  While libpng will not

- * normally need that much memory in a chunk (unless you load up a very

- * large file), zlib needs to know how big of a chunk it can use, and

- * libpng thus makes sure to check any memory allocation to verify it

- * will fit into memory.

-#define PNG_MAX_MALLOC_64K

- */

-#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)

-#  define PNG_MAX_MALLOC_64K

-#endif

-

-/* Special munging to support doing things the 'cygwin' way:

- * 'Normal' png-on-win32 defines/defaults:

- *   PNG_BUILD_DLL -- building dll

- *   PNG_USE_DLL   -- building an application, linking to dll

- *   (no define)   -- building static library, or building an

- *                    application and linking to the static lib

- * 'Cygwin' defines/defaults:

- *   PNG_BUILD_DLL -- (ignored) building the dll

- *   (no define)   -- (ignored) building an application, linking to the dll

- *   PNG_STATIC    -- (ignored) building the static lib, or building an

- *                    application that links to the static lib.

- *   ALL_STATIC    -- (ignored) building various static libs, or building an

- *                    application that links to the static libs.

- * Thus,

- * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and

- * this bit of #ifdefs will define the 'correct' config variables based on

- * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but

- * unnecessary.

- *

- * Also, the precedence order is:

- *   ALL_STATIC (since we can't #undef something outside our namespace)

- *   PNG_BUILD_DLL

- *   PNG_STATIC

- *   (nothing) == PNG_USE_DLL

- *

- * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent

- *   of auto-import in binutils, we no longer need to worry about

- *   __declspec(dllexport) / __declspec(dllimport) and friends.  Therefore,

- *   we don't need to worry about PNG_STATIC or ALL_STATIC when it comes

- *   to __declspec() stuff.  However, we DO need to worry about

- *   PNG_BUILD_DLL and PNG_STATIC because those change some defaults

- *   such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed.

- */

-#ifdef __CYGWIN__

-#  ifdef ALL_STATIC

-#    ifdef PNG_BUILD_DLL

-#      undef PNG_BUILD_DLL

-#    endif

-#    ifdef PNG_USE_DLL

-#      undef PNG_USE_DLL

-#    endif

-#    ifdef PNG_DLL

-#      undef PNG_DLL

-#    endif

-#    ifndef PNG_STATIC

-#      define PNG_STATIC

-#    endif

-#  else

-#    ifdef PNG_BUILD_DLL

-#      ifdef PNG_STATIC

-#        undef PNG_STATIC

-#      endif

-#      ifdef PNG_USE_DLL

-#        undef PNG_USE_DLL

-#      endif

-#      ifndef PNG_DLL

-#        define PNG_DLL

-#      endif

-#    else

-#      ifdef PNG_STATIC

-#        ifdef PNG_USE_DLL

-#          undef PNG_USE_DLL

-#        endif

-#        ifdef PNG_DLL

-#          undef PNG_DLL

-#        endif

-#      else

-#        ifndef PNG_USE_DLL

-#          define PNG_USE_DLL

-#        endif

-#        ifndef PNG_DLL

-#          define PNG_DLL

-#        endif

-#      endif

-#    endif

-#  endif

-#endif

-

-/* This protects us against compilers that run on a windowing system

- * and thus don't have or would rather us not use the stdio types:

- * stdin, stdout, and stderr.  The only one currently used is stderr

- * in png_error() and png_warning().  #defining PNG_NO_CONSOLE_IO will

- * prevent these from being compiled and used. #defining PNG_NO_STDIO

- * will also prevent these, plus will prevent the entire set of stdio

- * macros and functions (FILE *, printf, etc.) from being compiled and used,

- * unless (PNG_DEBUG > 0) has been #defined.

- *

- * #define PNG_NO_CONSOLE_IO

- * #define PNG_NO_STDIO

- */

-

-#if !defined(PNG_NO_STDIO) && !defined(PNG_STDIO_SUPPORTED)

-#  define PNG_STDIO_SUPPORTED

-#endif

-

-#ifdef _WIN32_WCE

-#  include <windows.h>

-   /* Console I/O functions are not supported on WindowsCE */

-#  define PNG_NO_CONSOLE_IO

-   /* abort() may not be supported on some/all Windows CE platforms */

-#  define PNG_ABORT() exit(-1)

-#  ifdef PNG_DEBUG

-#    undef PNG_DEBUG

-#  endif

-#endif

-

-#ifdef PNG_BUILD_DLL

-#  ifndef PNG_CONSOLE_IO_SUPPORTED

-#    ifndef PNG_NO_CONSOLE_IO

-#      define PNG_NO_CONSOLE_IO

-#    endif

-#  endif

-#endif

-

-#  ifdef PNG_NO_STDIO

-#    ifndef PNG_NO_CONSOLE_IO

-#      define PNG_NO_CONSOLE_IO

-#    endif

-#    ifdef PNG_DEBUG

-#      if (PNG_DEBUG > 0)

-#        include <stdio.h>

-#      endif

-#    endif

-#  else

-#    ifndef _WIN32_WCE

-/* "stdio.h" functions are not supported on WindowsCE */

-#      include <stdio.h>

-#    endif

-#  endif

-

-#if !(defined PNG_NO_CONSOLE_IO) && !defined(PNG_CONSOLE_IO_SUPPORTED)

-#  define PNG_CONSOLE_IO_SUPPORTED

-#endif

-

-/* This macro protects us against machines that don't have function

- * prototypes (ie K&R style headers).  If your compiler does not handle

- * function prototypes, define this macro and use the included ansi2knr.

- * I've always been able to use _NO_PROTO as the indicator, but you may

- * need to drag the empty declaration out in front of here, or change the

- * ifdef to suit your own needs.

- */

-#ifndef PNGARG

-

-#ifdef OF /* zlib prototype munger */

-#  define PNGARG(arglist) OF(arglist)

-#else

-

-#ifdef _NO_PROTO

-#  define PNGARG(arglist) ()

-#  ifndef PNG_TYPECAST_NULL

-#     define PNG_TYPECAST_NULL

-#  endif

-#else

-#  define PNGARG(arglist) arglist

-#endif /* _NO_PROTO */

-

-

-#endif /* OF */

-

-#endif /* PNGARG */

-

-/* Try to determine if we are compiling on a Mac.  Note that testing for

- * just __MWERKS__ is not good enough, because the Codewarrior is now used

- * on non-Mac platforms.

- */

-#ifndef MACOS

-#  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \

-      defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)

-#    define MACOS

-#  endif

-#endif

-

-/* enough people need this for various reasons to include it here */

-#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE)

-#  include <sys/types.h>

-#endif

-

-#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED)

-#  define PNG_SETJMP_SUPPORTED

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-/* This is an attempt to force a single setjmp behaviour on Linux.  If

- * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.

- *

- * You can bypass this test if you know that your application uses exactly

- * the same setjmp.h that was included when libpng was built.  Only define

- * PNG_SKIP_SETJMP_CHECK while building your application, prior to the

- * application's '#include "png.h"'. Don't define PNG_SKIP_SETJMP_CHECK

- * while building a separate libpng library for general use.

- */

-

-#  ifndef PNG_SKIP_SETJMP_CHECK

-#    ifdef __linux__

-#      ifdef _BSD_SOURCE

-#        define PNG_SAVE_BSD_SOURCE

-#        undef _BSD_SOURCE

-#      endif

-#      ifdef _SETJMP_H

-       /* If you encounter a compiler error here, see the explanation

-        * near the end of INSTALL.

-        */

-           __pngconf.h__ in libpng already includes setjmp.h;

-           __dont__ include it again.;

-#      endif

-#    endif /* __linux__ */

-#  endif /* PNG_SKIP_SETJMP_CHECK */

-

-   /* include setjmp.h for error handling */

-#  include <setjmp.h>

-

-#  ifdef __linux__

-#    ifdef PNG_SAVE_BSD_SOURCE

-#      ifndef _BSD_SOURCE

-#        define _BSD_SOURCE

-#      endif

-#      undef PNG_SAVE_BSD_SOURCE

-#    endif

-#  endif /* __linux__ */

-#endif /* PNG_SETJMP_SUPPORTED */

-

-#ifdef BSD

-#  include <strings.h>

-#else

-#  include <string.h>

-#endif

-

-/* Other defines for things like memory and the like can go here.  */

-#ifdef PNG_INTERNAL

-

-#include <stdlib.h>

-

-/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which

- * aren't usually used outside the library (as far as I know), so it is

- * debatable if they should be exported at all.  In the future, when it is

- * possible to have run-time registry of chunk-handling functions, some of

- * these will be made available again.

-#define PNG_EXTERN extern

- */

-#define PNG_EXTERN

-

-/* Other defines specific to compilers can go here.  Try to keep

- * them inside an appropriate ifdef/endif pair for portability.

- */

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-#  ifdef MACOS

-     /* We need to check that <math.h> hasn't already been included earlier

-      * as it seems it doesn't agree with <fp.h>, yet we should really use

-      * <fp.h> if possible.

-      */

-#    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)

-#      include <fp.h>

-#    endif

-#  else

-#    include <math.h>

-#  endif

-#  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)

-     /* Amiga SAS/C: We must include builtin FPU functions when compiling using

-      * MATH=68881

-      */

-#    include <m68881.h>

-#  endif

-#endif

-

-/* Codewarrior on NT has linking problems without this. */

-#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__)

-#  define PNG_ALWAYS_EXTERN

-#endif

-

-/* This provides the non-ANSI (far) memory allocation routines. */

-#if defined(__TURBOC__) && defined(__MSDOS__)

-#  include <mem.h>

-#  include <alloc.h>

-#endif

-

-/* I have no idea why is this necessary... */

-#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \

-    defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__))

-#  include <malloc.h>

-#endif

-

-/* This controls how fine the dithering gets.  As this allocates

- * a largish chunk of memory (32K), those who are not as concerned

- * with dithering quality can decrease some or all of these.

- */

-#ifndef PNG_DITHER_RED_BITS

-#  define PNG_DITHER_RED_BITS 5

-#endif

-#ifndef PNG_DITHER_GREEN_BITS

-#  define PNG_DITHER_GREEN_BITS 5

-#endif

-#ifndef PNG_DITHER_BLUE_BITS

-#  define PNG_DITHER_BLUE_BITS 5

-#endif

-

-/* This controls how fine the gamma correction becomes when you

- * are only interested in 8 bits anyway.  Increasing this value

- * results in more memory being used, and more pow() functions

- * being called to fill in the gamma tables.  Don't set this value

- * less then 8, and even that may not work (I haven't tested it).

- */

-

-#ifndef PNG_MAX_GAMMA_8

-#  define PNG_MAX_GAMMA_8 11

-#endif

-

-/* This controls how much a difference in gamma we can tolerate before

- * we actually start doing gamma conversion.

- */

-#ifndef PNG_GAMMA_THRESHOLD

-#  define PNG_GAMMA_THRESHOLD 0.05

-#endif

-

-#endif /* PNG_INTERNAL */

-

-/* The following uses const char * instead of char * for error

- * and warning message functions, so some compilers won't complain.

- * If you do not want to use const, define PNG_NO_CONST here.

- */

-

-#ifndef PNG_NO_CONST

-#  define PNG_CONST const

-#else

-#  define PNG_CONST

-#endif

-

-/* The following defines give you the ability to remove code from the

- * library that you will not be using.  I wish I could figure out how to

- * automate this, but I can't do that without making it seriously hard

- * on the users.  So if you are not using an ability, change the #define

- * to and #undef, and that part of the library will not be compiled.  If

- * your linker can't find a function, you may want to make sure the

- * ability is defined here.  Some of these depend upon some others being

- * defined.  I haven't figured out all the interactions here, so you may

- * have to experiment awhile to get everything to compile.  If you are

- * creating or using a shared library, you probably shouldn't touch this,

- * as it will affect the size of the structures, and this will cause bad

- * things to happen if the library and/or application ever change.

- */

-

-/* Any features you will not be using can be undef'ed here */

-

-/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user

- * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS

- * on the compile line, then pick and choose which ones to define without

- * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED

- * if you only want to have a png-compliant reader/writer but don't need

- * any of the extra transformations.  This saves about 80 kbytes in a

- * typical installation of the library. (PNG_NO_* form added in version

- * 1.0.1c, for consistency)

- */

-

-/* The size of the png_text structure changed in libpng-1.0.6 when

- * iTXt support was added.  iTXt support was turned off by default through

- * libpng-1.2.x, to support old apps that malloc the png_text structure

- * instead of calling png_set_text() and letting libpng malloc it.  It

- * will be turned on by default in libpng-1.4.0.

- */

-

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-#  ifndef PNG_NO_iTXt_SUPPORTED

-#    define PNG_NO_iTXt_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_iTXt

-#    define PNG_NO_READ_iTXt

-#  endif

-#  ifndef PNG_NO_WRITE_iTXt

-#    define PNG_NO_WRITE_iTXt

-#  endif

-#endif

-

-#if !defined(PNG_NO_iTXt_SUPPORTED)

-#  if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt)

-#    define PNG_READ_iTXt

-#  endif

-#  if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt)

-#    define PNG_WRITE_iTXt

-#  endif

-#endif

-

-/* The following support, added after version 1.0.0, can be turned off here en

- * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility

- * with old applications that require the length of png_struct and png_info

- * to remain unchanged.

- */

-

-#ifdef PNG_LEGACY_SUPPORTED

-#  define PNG_NO_FREE_ME

-#  define PNG_NO_READ_UNKNOWN_CHUNKS

-#  define PNG_NO_WRITE_UNKNOWN_CHUNKS

-#  define PNG_NO_HANDLE_AS_UNKNOWN

-#  define PNG_NO_READ_USER_CHUNKS

-#  define PNG_NO_READ_iCCP

-#  define PNG_NO_WRITE_iCCP

-#  define PNG_NO_READ_iTXt

-#  define PNG_NO_WRITE_iTXt

-#  define PNG_NO_READ_sCAL

-#  define PNG_NO_WRITE_sCAL

-#  define PNG_NO_READ_sPLT

-#  define PNG_NO_WRITE_sPLT

-#  define PNG_NO_INFO_IMAGE

-#  define PNG_NO_READ_RGB_TO_GRAY

-#  define PNG_NO_READ_USER_TRANSFORM

-#  define PNG_NO_WRITE_USER_TRANSFORM

-#  define PNG_NO_USER_MEM

-#  define PNG_NO_READ_EMPTY_PLTE

-#  define PNG_NO_MNG_FEATURES

-#  define PNG_NO_FIXED_POINT_SUPPORTED

-#endif

-

-/* Ignore attempt to turn off both floating and fixed point support */

-#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \

-    !defined(PNG_NO_FIXED_POINT_SUPPORTED)

-#  define PNG_FIXED_POINT_SUPPORTED

-#endif

-

-#ifndef PNG_NO_FREE_ME

-#  define PNG_FREE_ME_SUPPORTED

-#endif

-

-#ifdef PNG_READ_SUPPORTED

-

-#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \

-      !defined(PNG_NO_READ_TRANSFORMS)

-#  define PNG_READ_TRANSFORMS_SUPPORTED

-#endif

-

-#ifdef PNG_READ_TRANSFORMS_SUPPORTED

-#  ifndef PNG_NO_READ_EXPAND

-#    define PNG_READ_EXPAND_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_SHIFT

-#    define PNG_READ_SHIFT_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_PACK

-#    define PNG_READ_PACK_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_BGR

-#    define PNG_READ_BGR_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_SWAP

-#    define PNG_READ_SWAP_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_PACKSWAP

-#    define PNG_READ_PACKSWAP_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_INVERT

-#    define PNG_READ_INVERT_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_DITHER

-#    define PNG_READ_DITHER_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_BACKGROUND

-#    define PNG_READ_BACKGROUND_SUPPORTED

-#  endif

-#ifndef PNG_1_0_X

-#  ifndef PNG_NO_READ_16_TO_8

-#    define PNG_READ_16_TO_8_SUPPORTED

-#  endif

-#endif

-#  ifndef PNG_NO_READ_FILLER

-#    define PNG_READ_FILLER_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_GAMMA

-#    define PNG_READ_GAMMA_SUPPORTED

-#  endif

-#ifndef PNG_1_0_X

-#  ifndef PNG_NO_READ_GRAY_TO_RGB

-#    define PNG_READ_GRAY_TO_RGB_SUPPORTED

-#  endif

-#endif

-#  ifndef PNG_NO_READ_SWAP_ALPHA

-#    define PNG_READ_SWAP_ALPHA_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_INVERT_ALPHA

-#    define PNG_READ_INVERT_ALPHA_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_STRIP_ALPHA

-#    define PNG_READ_STRIP_ALPHA_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_USER_TRANSFORM

-#    define PNG_READ_USER_TRANSFORM_SUPPORTED

-#  endif

-#  ifndef PNG_NO_READ_RGB_TO_GRAY

-#    define PNG_READ_RGB_TO_GRAY_SUPPORTED

-#  endif

-#endif /* PNG_READ_TRANSFORMS_SUPPORTED */

-

-/* PNG_PROGRESSIVE_READ_NOT_SUPPORTED is deprecated. */

-#if !defined(PNG_NO_PROGRESSIVE_READ) && \

- !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED)  /* if you don't do progressive */

-#  define PNG_PROGRESSIVE_READ_SUPPORTED     /* reading.  This is not talking */

-#endif                               /* about interlacing capability!  You'll */

-            /* still have interlacing unless you change the following define: */

-#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */

-

-/* PNG_NO_SEQUENTIAL_READ_SUPPORTED is deprecated. */

-#if !defined(PNG_NO_SEQUENTIAL_READ) && \

-    !defined(PNG_SEQUENTIAL_READ_SUPPORTED) && \

-    !defined(PNG_NO_SEQUENTIAL_READ_SUPPORTED)

-#  define PNG_SEQUENTIAL_READ_SUPPORTED

-#endif

-

-#define PNG_READ_INTERLACING_SUPPORTED /* required in PNG-compliant decoders */

-

-#ifndef PNG_NO_READ_COMPOSITE_NODIV

-#  ifndef PNG_NO_READ_COMPOSITED_NODIV  /* libpng-1.0.x misspelling */

-#    define PNG_READ_COMPOSITE_NODIV_SUPPORTED  /* well tested on Intel, SGI */

-#  endif

-#endif

-

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-/* Deprecated, will be removed from version 2.0.0.

-   Use PNG_MNG_FEATURES_SUPPORTED instead. */

-#ifndef PNG_NO_READ_EMPTY_PLTE

-#  define PNG_READ_EMPTY_PLTE_SUPPORTED

-#endif

-#endif

-

-#endif /* PNG_READ_SUPPORTED */

-

-#ifdef PNG_WRITE_SUPPORTED

-

-# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \

-    !defined(PNG_NO_WRITE_TRANSFORMS)

-#  define PNG_WRITE_TRANSFORMS_SUPPORTED

-#endif

-

-#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED

-#  ifndef PNG_NO_WRITE_SHIFT

-#    define PNG_WRITE_SHIFT_SUPPORTED

-#  endif

-#  ifndef PNG_NO_WRITE_PACK

-#    define PNG_WRITE_PACK_SUPPORTED

-#  endif

-#  ifndef PNG_NO_WRITE_BGR

-#    define PNG_WRITE_BGR_SUPPORTED

-#  endif

-#  ifndef PNG_NO_WRITE_SWAP

-#    define PNG_WRITE_SWAP_SUPPORTED

-#  endif

-#  ifndef PNG_NO_WRITE_PACKSWAP

-#    define PNG_WRITE_PACKSWAP_SUPPORTED

-#  endif

-#  ifndef PNG_NO_WRITE_INVERT

-#    define PNG_WRITE_INVERT_SUPPORTED

-#  endif

-#  ifndef PNG_NO_WRITE_FILLER

-#    define PNG_WRITE_FILLER_SUPPORTED   /* same as WRITE_STRIP_ALPHA */

-#  endif

-#  ifndef PNG_NO_WRITE_SWAP_ALPHA

-#    define PNG_WRITE_SWAP_ALPHA_SUPPORTED

-#  endif

-#ifndef PNG_1_0_X

-#  ifndef PNG_NO_WRITE_INVERT_ALPHA

-#    define PNG_WRITE_INVERT_ALPHA_SUPPORTED

-#  endif

-#endif

-#  ifndef PNG_NO_WRITE_USER_TRANSFORM

-#    define PNG_WRITE_USER_TRANSFORM_SUPPORTED

-#  endif

-#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */

-

-#if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \

-    !defined(PNG_WRITE_INTERLACING_SUPPORTED)

-#define PNG_WRITE_INTERLACING_SUPPORTED  /* not required for PNG-compliant

-                                            encoders, but can cause trouble

-                                            if left undefined */

-#endif

-

-#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \

-    !defined(PNG_WRITE_WEIGHTED_FILTER) && \

-     defined(PNG_FLOATING_POINT_SUPPORTED)

-#  define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-#endif

-

-#ifndef PNG_NO_WRITE_FLUSH

-#  define PNG_WRITE_FLUSH_SUPPORTED

-#endif

-

-#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

-/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */

-#ifndef PNG_NO_WRITE_EMPTY_PLTE

-#  define PNG_WRITE_EMPTY_PLTE_SUPPORTED

-#endif

-#endif

-

-#endif /* PNG_WRITE_SUPPORTED */

-

-#define PNG_NO_ERROR_NUMBERS

-#ifndef PNG_1_0_X

-#  ifndef PNG_NO_ERROR_NUMBERS

-#    define PNG_ERROR_NUMBERS_SUPPORTED

-#  endif

-#endif /* PNG_1_0_X */

-

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

-#  ifndef PNG_NO_USER_TRANSFORM_PTR

-#    define PNG_USER_TRANSFORM_PTR_SUPPORTED

-#  endif

-#endif

-

-#ifndef PNG_NO_STDIO

-#  define PNG_TIME_RFC1123_SUPPORTED

-#endif

-

-/* This adds extra functions in pngget.c for accessing data from the

- * info pointer (added in version 0.99)

- * png_get_image_width()

- * png_get_image_height()

- * png_get_bit_depth()

- * png_get_color_type()

- * png_get_compression_type()

- * png_get_filter_type()

- * png_get_interlace_type()

- * png_get_pixel_aspect_ratio()

- * png_get_pixels_per_meter()

- * png_get_x_offset_pixels()

- * png_get_y_offset_pixels()

- * png_get_x_offset_microns()

- * png_get_y_offset_microns()

- */

-#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED)

-#  define PNG_EASY_ACCESS_SUPPORTED

-#endif

-

-/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0

- * and removed from version 1.2.20.  The following will be removed

- * from libpng-1.4.0

-*/

-

-#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_OPTIMIZED_CODE)

-#  ifndef PNG_OPTIMIZED_CODE_SUPPORTED

-#    define PNG_OPTIMIZED_CODE_SUPPORTED

-#  endif

-#endif

-

-#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE)

-#  ifndef PNG_ASSEMBLER_CODE_SUPPORTED

-#    define PNG_ASSEMBLER_CODE_SUPPORTED

-#  endif

-

-#  if defined(__GNUC__) && defined(__x86_64__) && (__GNUC__ < 4)

-     /* work around 64-bit gcc compiler bugs in gcc-3.x */

-#    if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)

-#      define PNG_NO_MMX_CODE

-#    endif

-#  endif

-

-#  ifdef __APPLE__

-#    if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)

-#      define PNG_NO_MMX_CODE

-#    endif

-#  endif

-

-#  if (defined(__MWERKS__) && ((__MWERKS__ < 0x0900) || macintosh))

-#    if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)

-#      define PNG_NO_MMX_CODE

-#    endif

-#  endif

-

-#  if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)

-#    define PNG_MMX_CODE_SUPPORTED

-#  endif

-

-#endif

-/* end of obsolete code to be removed from libpng-1.4.0 */

-

-/* Added at libpng-1.2.0 */

-#ifndef PNG_1_0_X

-#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED)

-#  define PNG_USER_MEM_SUPPORTED

-#endif

-#endif /* PNG_1_0_X */

-

-/* Added at libpng-1.2.6 */

-#ifndef PNG_1_0_X

-#  ifndef PNG_SET_USER_LIMITS_SUPPORTED

-#    ifndef PNG_NO_SET_USER_LIMITS

-#      define PNG_SET_USER_LIMITS_SUPPORTED

-#    endif

-#  endif

-#endif /* PNG_1_0_X */

-

-/* Added at libpng-1.0.16 and 1.2.6.  To accept all valid PNGS no matter

- * how large, set these limits to 0x7fffffffL

- */

-#ifndef PNG_USER_WIDTH_MAX

-#  define PNG_USER_WIDTH_MAX 1000000L

-#endif

-#ifndef PNG_USER_HEIGHT_MAX

-#  define PNG_USER_HEIGHT_MAX 1000000L

-#endif

-

-#ifndef PNG_1_0_X

-/* Added at libpng-1.2.41 */

-#ifndef PNG_USER_CHUNK_CACHE_MAX

-#  define PNG_USER_CHUNK_CACHE_MAX 0x7fffffffL

-#endif

-#endif

-

-#ifndef PNG_LITERAL_SHARP

-#  define PNG_LITERAL_SHARP 0x23

-#endif

-#ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET

-#  define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b

-#endif

-#ifndef PNG_LITERAL_RIGHT_SQUARE_BRACKET

-#  define PNG_LITERAL_RIGHT_SQUARE_BRACKET 0x5d

-#endif

-

-/* Added at libpng-1.2.34 */

-#ifndef PNG_STRING_NEWLINE

-#define PNG_STRING_NEWLINE "\n"

-#endif

-

-/* These are currently experimental features, define them if you want */

-

-/* very little testing */

-/*

-#ifdef PNG_READ_SUPPORTED

-#  ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED

-#    define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED

-#  endif

-#endif

-*/

-

-/* This is only for PowerPC big-endian and 680x0 systems */

-/* some testing */

-/*

-#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED

-#  define PNG_READ_BIG_ENDIAN_SUPPORTED

-#endif

-*/

-

-/* Buggy compilers (e.g., gcc 2.7.2.2) need this */

-/*

-#define PNG_NO_POINTER_INDEXING

-*/

-

-#if !defined(PNG_NO_POINTER_INDEXING) && \

-    !defined(PNG_POINTER_INDEXING_SUPPORTED)

-#  define PNG_POINTER_INDEXING_SUPPORTED

-#endif

-

-/* These functions are turned off by default, as they will be phased out. */

-/*

-#define  PNG_USELESS_TESTS_SUPPORTED

-#define  PNG_CORRECT_PALETTE_SUPPORTED

-*/

-

-/* Any chunks you are not interested in, you can undef here.  The

- * ones that allocate memory may be expecially important (hIST,

- * tEXt, zTXt, tRNS, pCAL).  Others will just save time and make png_info

- * a bit smaller.

- */

-

-#if defined(PNG_READ_SUPPORTED) && \

-    !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \

-    !defined(PNG_NO_READ_ANCILLARY_CHUNKS)

-#  define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED

-#endif

-

-#if defined(PNG_WRITE_SUPPORTED) && \

-    !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \

-    !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)

-#  define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED

-#endif

-

-#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED

-

-#ifdef PNG_NO_READ_TEXT

-#  define PNG_NO_READ_iTXt

-#  define PNG_NO_READ_tEXt

-#  define PNG_NO_READ_zTXt

-#endif

-#ifndef PNG_NO_READ_bKGD

-#  define PNG_READ_bKGD_SUPPORTED

-#  define PNG_bKGD_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_cHRM

-#  define PNG_READ_cHRM_SUPPORTED

-#  define PNG_cHRM_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_gAMA

-#  define PNG_READ_gAMA_SUPPORTED

-#  define PNG_gAMA_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_hIST

-#  define PNG_READ_hIST_SUPPORTED

-#  define PNG_hIST_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_iCCP

-#  define PNG_READ_iCCP_SUPPORTED

-#  define PNG_iCCP_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_iTXt

-#  ifndef PNG_READ_iTXt_SUPPORTED

-#    define PNG_READ_iTXt_SUPPORTED

-#  endif

-#  ifndef PNG_iTXt_SUPPORTED

-#    define PNG_iTXt_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_READ_oFFs

-#  define PNG_READ_oFFs_SUPPORTED

-#  define PNG_oFFs_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_pCAL

-#  define PNG_READ_pCAL_SUPPORTED

-#  define PNG_pCAL_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_sCAL

-#  define PNG_READ_sCAL_SUPPORTED

-#  define PNG_sCAL_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_pHYs

-#  define PNG_READ_pHYs_SUPPORTED

-#  define PNG_pHYs_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_sBIT

-#  define PNG_READ_sBIT_SUPPORTED

-#  define PNG_sBIT_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_sPLT

-#  define PNG_READ_sPLT_SUPPORTED

-#  define PNG_sPLT_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_sRGB

-#  define PNG_READ_sRGB_SUPPORTED

-#  define PNG_sRGB_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_tEXt

-#  define PNG_READ_tEXt_SUPPORTED

-#  define PNG_tEXt_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_tIME

-#  define PNG_READ_tIME_SUPPORTED

-#  define PNG_tIME_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_tRNS

-#  define PNG_READ_tRNS_SUPPORTED

-#  define PNG_tRNS_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_zTXt

-#  define PNG_READ_zTXt_SUPPORTED

-#  define PNG_zTXt_SUPPORTED

-#endif

-#ifndef PNG_NO_READ_OPT_PLTE

-#  define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */

-#endif                      /* optional PLTE chunk in RGB and RGBA images */

-#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \

-    defined(PNG_READ_zTXt_SUPPORTED)

-#  define PNG_READ_TEXT_SUPPORTED

-#  define PNG_TEXT_SUPPORTED

-#endif

-

-#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */

-

-#ifndef PNG_NO_READ_UNKNOWN_CHUNKS

-#  define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED

-#    define PNG_UNKNOWN_CHUNKS_SUPPORTED

-#  endif

-#endif

-#if !defined(PNG_NO_READ_USER_CHUNKS) && \

-     defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

-#  define PNG_READ_USER_CHUNKS_SUPPORTED

-#  define PNG_USER_CHUNKS_SUPPORTED

-#  ifdef PNG_NO_READ_UNKNOWN_CHUNKS

-#    undef PNG_NO_READ_UNKNOWN_CHUNKS

-#  endif

-#  ifdef PNG_NO_HANDLE_AS_UNKNOWN

-#    undef PNG_NO_HANDLE_AS_UNKNOWN

-#  endif

-#endif

-

-#ifndef PNG_NO_HANDLE_AS_UNKNOWN

-#  ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-#    define PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-#  endif

-#endif

-

-#ifdef PNG_WRITE_SUPPORTED

-#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED

-

-#ifdef PNG_NO_WRITE_TEXT

-#  define PNG_NO_WRITE_iTXt

-#  define PNG_NO_WRITE_tEXt

-#  define PNG_NO_WRITE_zTXt

-#endif

-#ifndef PNG_NO_WRITE_bKGD

-#  define PNG_WRITE_bKGD_SUPPORTED

-#  ifndef PNG_bKGD_SUPPORTED

-#    define PNG_bKGD_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_cHRM

-#  define PNG_WRITE_cHRM_SUPPORTED

-#  ifndef PNG_cHRM_SUPPORTED

-#    define PNG_cHRM_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_gAMA

-#  define PNG_WRITE_gAMA_SUPPORTED

-#  ifndef PNG_gAMA_SUPPORTED

-#    define PNG_gAMA_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_hIST

-#  define PNG_WRITE_hIST_SUPPORTED

-#  ifndef PNG_hIST_SUPPORTED

-#    define PNG_hIST_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_iCCP

-#  define PNG_WRITE_iCCP_SUPPORTED

-#  ifndef PNG_iCCP_SUPPORTED

-#    define PNG_iCCP_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_iTXt

-#  ifndef PNG_WRITE_iTXt_SUPPORTED

-#    define PNG_WRITE_iTXt_SUPPORTED

-#  endif

-#  ifndef PNG_iTXt_SUPPORTED

-#    define PNG_iTXt_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_oFFs

-#  define PNG_WRITE_oFFs_SUPPORTED

-#  ifndef PNG_oFFs_SUPPORTED

-#    define PNG_oFFs_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_pCAL

-#  define PNG_WRITE_pCAL_SUPPORTED

-#  ifndef PNG_pCAL_SUPPORTED

-#    define PNG_pCAL_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_sCAL

-#  define PNG_WRITE_sCAL_SUPPORTED

-#  ifndef PNG_sCAL_SUPPORTED

-#    define PNG_sCAL_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_pHYs

-#  define PNG_WRITE_pHYs_SUPPORTED

-#  ifndef PNG_pHYs_SUPPORTED

-#    define PNG_pHYs_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_sBIT

-#  define PNG_WRITE_sBIT_SUPPORTED

-#  ifndef PNG_sBIT_SUPPORTED

-#    define PNG_sBIT_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_sPLT

-#  define PNG_WRITE_sPLT_SUPPORTED

-#  ifndef PNG_sPLT_SUPPORTED

-#    define PNG_sPLT_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_sRGB

-#  define PNG_WRITE_sRGB_SUPPORTED

-#  ifndef PNG_sRGB_SUPPORTED

-#    define PNG_sRGB_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_tEXt

-#  define PNG_WRITE_tEXt_SUPPORTED

-#  ifndef PNG_tEXt_SUPPORTED

-#    define PNG_tEXt_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_tIME

-#  define PNG_WRITE_tIME_SUPPORTED

-#  ifndef PNG_tIME_SUPPORTED

-#    define PNG_tIME_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_tRNS

-#  define PNG_WRITE_tRNS_SUPPORTED

-#  ifndef PNG_tRNS_SUPPORTED

-#    define PNG_tRNS_SUPPORTED

-#  endif

-#endif

-#ifndef PNG_NO_WRITE_zTXt

-#  define PNG_WRITE_zTXt_SUPPORTED

-#  ifndef PNG_zTXt_SUPPORTED

-#    define PNG_zTXt_SUPPORTED

-#  endif

-#endif

-#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \

-    defined(PNG_WRITE_zTXt_SUPPORTED)

-#  define PNG_WRITE_TEXT_SUPPORTED

-#  ifndef PNG_TEXT_SUPPORTED

-#    define PNG_TEXT_SUPPORTED

-#  endif

-#endif

-

-#ifdef PNG_WRITE_tIME_SUPPORTED

-#  ifndef PNG_NO_CONVERT_tIME

-#    ifndef _WIN32_WCE

-/*   The "tm" structure is not supported on WindowsCE */

-#      ifndef PNG_CONVERT_tIME_SUPPORTED

-#        define PNG_CONVERT_tIME_SUPPORTED

-#      endif

-#   endif

-#  endif

-#endif

-

-#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */

-

-#if !defined(PNG_NO_WRITE_FILTER) && !defined(PNG_WRITE_FILTER_SUPPORTED)

-#  define PNG_WRITE_FILTER_SUPPORTED

-#endif

-

-#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS

-#  define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED

-#    define PNG_UNKNOWN_CHUNKS_SUPPORTED

-#  endif

-#endif

-

-#ifndef PNG_NO_HANDLE_AS_UNKNOWN

-#  ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-#    define PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-#  endif

-#endif

-#endif /* PNG_WRITE_SUPPORTED */

-

-/* Turn this off to disable png_read_png() and

- * png_write_png() and leave the row_pointers member

- * out of the info structure.

- */

-#ifndef PNG_NO_INFO_IMAGE

-#  define PNG_INFO_IMAGE_SUPPORTED

-#endif

-

-/* Need the time information for converting tIME chunks */

-#ifdef PNG_CONVERT_tIME_SUPPORTED

-     /* "time.h" functions are not supported on WindowsCE */

-#    include <time.h>

-#endif

-

-/* Some typedefs to get us started.  These should be safe on most of the

- * common platforms.  The typedefs should be at least as large as the

- * numbers suggest (a png_uint_32 must be at least 32 bits long), but they

- * don't have to be exactly that size.  Some compilers dislike passing

- * unsigned shorts as function parameters, so you may be better off using

- * unsigned int for png_uint_16.  Likewise, for 64-bit systems, you may

- * want to have unsigned int for png_uint_32 instead of unsigned long.

- */

-

-typedef unsigned long png_uint_32;

-typedef long png_int_32;

-typedef unsigned short png_uint_16;

-typedef short png_int_16;

-typedef unsigned char png_byte;

-

-/* This is usually size_t.  It is typedef'ed just in case you need it to

-   change (I'm not sure if you will or not, so I thought I'd be safe) */

-#ifdef PNG_SIZE_T

-   typedef PNG_SIZE_T png_size_t;

-#  define png_sizeof(x) png_convert_size(sizeof(x))

-#else

-   typedef size_t png_size_t;

-#  define png_sizeof(x) sizeof(x)

-#endif

-

-/* The following is needed for medium model support.  It cannot be in the

- * PNG_INTERNAL section.  Needs modification for other compilers besides

- * MSC.  Model independent support declares all arrays and pointers to be

- * large using the far keyword.  The zlib version used must also support

- * model independent data.  As of version zlib 1.0.4, the necessary changes

- * have been made in zlib.  The USE_FAR_KEYWORD define triggers other

- * changes that are needed. (Tim Wegner)

- */

-

-/* Separate compiler dependencies (problem here is that zlib.h always

-   defines FAR. (SJT) */

-#ifdef __BORLANDC__

-#  if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)

-#    define LDATA 1

-#  else

-#    define LDATA 0

-#  endif

-   /* GRR:  why is Cygwin in here?  Cygwin is not Borland C... */

-#  if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)

-#    define PNG_MAX_MALLOC_64K

-#    if (LDATA != 1)

-#      ifndef FAR

-#        define FAR __far

-#      endif

-#      define USE_FAR_KEYWORD

-#    endif   /* LDATA != 1 */

-     /* Possibly useful for moving data out of default segment.

-      * Uncomment it if you want. Could also define FARDATA as

-      * const if your compiler supports it. (SJT)

-#    define FARDATA FAR

-      */

-#  endif  /* __WIN32__, __FLAT__, __CYGWIN__ */

-#endif   /* __BORLANDC__ */

-

-

-/* Suggest testing for specific compiler first before testing for

- * FAR.  The Watcom compiler defines both __MEDIUM__ and M_I86MM,

- * making reliance oncertain keywords suspect. (SJT)

- */

-

-/* MSC Medium model */

-#ifdef FAR

-#  ifdef M_I86MM

-#    define USE_FAR_KEYWORD

-#    define FARDATA FAR

-#    include <dos.h>

-#  endif

-#endif

-

-/* SJT: default case */

-#ifndef FAR

-#  define FAR

-#endif

-

-/* At this point FAR is always defined */

-#ifndef FARDATA

-#  define FARDATA

-#endif

-

-/* Typedef for floating-point numbers that are converted

-   to fixed-point with a multiple of 100,000, e.g., int_gamma */

-typedef png_int_32 png_fixed_point;

-

-/* Add typedefs for pointers */

-typedef void            FAR * png_voidp;

-typedef png_byte        FAR * png_bytep;

-typedef png_uint_32     FAR * png_uint_32p;

-typedef png_int_32      FAR * png_int_32p;

-typedef png_uint_16     FAR * png_uint_16p;

-typedef png_int_16      FAR * png_int_16p;

-typedef PNG_CONST char  FAR * png_const_charp;

-typedef char            FAR * png_charp;

-typedef png_fixed_point FAR * png_fixed_point_p;

-

-#ifndef PNG_NO_STDIO

-#ifdef _WIN32_WCE

-typedef HANDLE                png_FILE_p;

-#else

-typedef FILE                * png_FILE_p;

-#endif

-#endif

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-typedef double          FAR * png_doublep;

-#endif

-

-/* Pointers to pointers; i.e. arrays */

-typedef png_byte        FAR * FAR * png_bytepp;

-typedef png_uint_32     FAR * FAR * png_uint_32pp;

-typedef png_int_32      FAR * FAR * png_int_32pp;

-typedef png_uint_16     FAR * FAR * png_uint_16pp;

-typedef png_int_16      FAR * FAR * png_int_16pp;

-typedef PNG_CONST char  FAR * FAR * png_const_charpp;

-typedef char            FAR * FAR * png_charpp;

-typedef png_fixed_point FAR * FAR * png_fixed_point_pp;

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-typedef double          FAR * FAR * png_doublepp;

-#endif

-

-/* Pointers to pointers to pointers; i.e., pointer to array */

-typedef char            FAR * FAR * FAR * png_charppp;

-

-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

-/* SPC -  Is this stuff deprecated? */

-/* It'll be removed as of libpng-1.4.0 - GR-P */

-/* libpng typedefs for types in zlib. If zlib changes

- * or another compression library is used, then change these.

- * Eliminates need to change all the source files.

- */

-typedef charf *         png_zcharp;

-typedef charf * FAR *   png_zcharpp;

-typedef z_stream FAR *  png_zstreamp;

-#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */

-

-/*

- * Define PNG_BUILD_DLL if the module being built is a Windows

- * LIBPNG DLL.

- *

- * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL.

- * It is equivalent to Microsoft predefined macro _DLL that is

- * automatically defined when you compile using the share

- * version of the CRT (C Run-Time library)

- *

- * The cygwin mods make this behavior a little different:

- * Define PNG_BUILD_DLL if you are building a dll for use with cygwin

- * Define PNG_STATIC if you are building a static library for use with cygwin,

- *   -or- if you are building an application that you want to link to the

- *   static library.

- * PNG_USE_DLL is defined by default (no user action needed) unless one of

- *   the other flags is defined.

- */

-

-#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL))

-#  define PNG_DLL

-#endif

-/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib.

- * When building a static lib, default to no GLOBAL ARRAYS, but allow

- * command-line override

- */

-#ifdef __CYGWIN__

-#  ifndef PNG_STATIC

-#    ifdef PNG_USE_GLOBAL_ARRAYS

-#      undef PNG_USE_GLOBAL_ARRAYS

-#    endif

-#    ifndef PNG_USE_LOCAL_ARRAYS

-#      define PNG_USE_LOCAL_ARRAYS

-#    endif

-#  else

-#    if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS)

-#      ifdef PNG_USE_GLOBAL_ARRAYS

-#        undef PNG_USE_GLOBAL_ARRAYS

-#      endif

-#    endif

-#  endif

-#  if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)

-#    define PNG_USE_LOCAL_ARRAYS

-#  endif

-#endif

-

-/* Do not use global arrays (helps with building DLL's)

- * They are no longer used in libpng itself, since version 1.0.5c,

- * but might be required for some pre-1.0.5c applications.

- */

-#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)

-#  if defined(PNG_NO_GLOBAL_ARRAYS) || \

-      (defined(__GNUC__) && defined(PNG_DLL)) || defined(_MSC_VER)

-#    define PNG_USE_LOCAL_ARRAYS

-#  else

-#    define PNG_USE_GLOBAL_ARRAYS

-#  endif

-#endif

-

-#ifdef __CYGWIN__

-#  undef PNGAPI

-#  define PNGAPI __cdecl

-#  undef PNG_IMPEXP

-#  define PNG_IMPEXP

-#endif

-

-/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall",

- * you may get warnings regarding the linkage of png_zalloc and png_zfree.

- * Don't ignore those warnings; you must also reset the default calling

- * convention in your compiler to match your PNGAPI, and you must build

- * zlib and your applications the same way you build libpng.

- */

-

-#if defined(__MINGW32__) && !defined(PNG_MODULEDEF)

-#  ifndef PNG_NO_MODULEDEF

-#    define PNG_NO_MODULEDEF

-#  endif

-#endif

-

-#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF)

-#  define PNG_IMPEXP

-#endif

-

-#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \

-    (( defined(_Windows) || defined(_WINDOWS) || \

-       defined(WIN32) || defined(_WIN32) || defined(__WIN32__) ))

-

-#  ifndef PNGAPI

-#     if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800))

-#        define PNGAPI __cdecl

-#     else

-#        define PNGAPI _cdecl

-#     endif

-#  endif

-

-#  if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \

-       0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */)

-#     define PNG_IMPEXP

-#  endif

-

-#  ifndef PNG_IMPEXP

-

-#     define PNG_EXPORT_TYPE1(type,symbol)  PNG_IMPEXP type PNGAPI symbol

-#     define PNG_EXPORT_TYPE2(type,symbol)  type PNG_IMPEXP PNGAPI symbol

-

-      /* Borland/Microsoft */

-#     if defined(_MSC_VER) || defined(__BORLANDC__)

-#        if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500)

-#           define PNG_EXPORT PNG_EXPORT_TYPE1

-#        else

-#           define PNG_EXPORT PNG_EXPORT_TYPE2

-#           ifdef PNG_BUILD_DLL

-#              define PNG_IMPEXP __export

-#           else

-#              define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in

-                                                 VC++ */

-#           endif                             /* Exists in Borland C++ for

-                                                 C++ classes (== huge) */

-#        endif

-#     endif

-

-#     ifndef PNG_IMPEXP

-#        ifdef PNG_BUILD_DLL

-#           define PNG_IMPEXP __declspec(dllexport)

-#        else

-#           define PNG_IMPEXP __declspec(dllimport)

-#        endif

-#     endif

-#  endif  /* PNG_IMPEXP */

-#else /* !(DLL || non-cygwin WINDOWS) */

-#   if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)

-#      ifndef PNGAPI

-#         define PNGAPI _System

-#      endif

-#   else

-#      if 0 /* ... other platforms, with other meanings */

-#      endif

-#   endif

-#endif

-

-#ifndef PNGAPI

-#  define PNGAPI

-#endif

-#ifndef PNG_IMPEXP

-#  define PNG_IMPEXP

-#endif

-

-#ifdef PNG_BUILDSYMS

-#  ifndef PNG_EXPORT

-#    define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END

-#  endif

-#  ifdef PNG_USE_GLOBAL_ARRAYS

-#    ifndef PNG_EXPORT_VAR

-#      define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT

-#    endif

-#  endif

-#endif

-

-#ifndef PNG_EXPORT

-#  define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol

-#endif

-

-#ifdef PNG_USE_GLOBAL_ARRAYS

-#  ifndef PNG_EXPORT_VAR

-#    define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type

-#  endif

-#endif

-

-#ifdef PNG_PEDANTIC_WARNINGS

-#  ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED

-#    define PNG_PEDANTIC_WARNINGS_SUPPORTED

-#  endif

-#endif

-

-#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED

-/* Support for compiler specific function attributes.  These are used

- * so that where compiler support is available incorrect use of API

- * functions in png.h will generate compiler warnings.  Added at libpng

- * version 1.2.41.

- */

-#  ifdef __GNUC__

-#    ifndef PNG_USE_RESULT

-#      define PNG_USE_RESULT __attribute__((__warn_unused_result__))

-#    endif

-#    ifndef PNG_NORETURN

-#      define PNG_NORETURN   __attribute__((__noreturn__))

-#    endif

-#    ifndef PNG_ALLOCATED

-#      define PNG_ALLOCATED  __attribute__((__malloc__))

-#    endif

-

-    /* This specifically protects structure members that should only be

-     * accessed from within the library, therefore should be empty during

-     * a library build.

-     */

-#    ifndef PNG_DEPRECATED

-#      define PNG_DEPRECATED __attribute__((__deprecated__))

-#    endif

-#    ifndef PNG_DEPSTRUCT

-#      define PNG_DEPSTRUCT  __attribute__((__deprecated__))

-#    endif

-#    ifndef PNG_PRIVATE

-#      if 0 /* Doesn't work so we use deprecated instead*/

-#        define PNG_PRIVATE \

-          __attribute__((warning("This function is not exported by libpng.")))

-#      else

-#        define PNG_PRIVATE \

-          __attribute__((__deprecated__))

-#      endif

-#    endif /* PNG_PRIVATE */

-#  endif /* __GNUC__ */

-#endif /* PNG_PEDANTIC_WARNINGS */

-

-#ifndef PNG_DEPRECATED

-#  define PNG_DEPRECATED  /* Use of this function is deprecated */

-#endif

-#ifndef PNG_USE_RESULT

-#  define PNG_USE_RESULT  /* The result of this function must be checked */

-#endif

-#ifndef PNG_NORETURN

-#  define PNG_NORETURN    /* This function does not return */

-#endif

-#ifndef PNG_ALLOCATED

-#  define PNG_ALLOCATED   /* The result of the function is new memory */

-#endif

-#ifndef PNG_DEPSTRUCT

-#  define PNG_DEPSTRUCT   /* Access to this struct member is deprecated */

-#endif

-#ifndef PNG_PRIVATE

-#  define PNG_PRIVATE     /* This is a private libpng function */

-#endif

-

-/* User may want to use these so they are not in PNG_INTERNAL. Any library

- * functions that are passed far data must be model independent.

- */

-

-#ifndef PNG_ABORT

-#  define PNG_ABORT() abort()

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)

-#else

-#  define png_jmpbuf(png_ptr) \

-   (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED)

-#endif

-

-#ifdef USE_FAR_KEYWORD  /* memory model independent fns */

-/* Use this to make far-to-near assignments */

-#  define CHECK   1

-#  define NOCHECK 0

-#  define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))

-#  define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))

-#  define png_snprintf _fsnprintf   /* Added to v 1.2.19 */

-#  define png_strlen  _fstrlen

-#  define png_memcmp  _fmemcmp    /* SJT: added */

-#  define png_memcpy  _fmemcpy

-#  define png_memset  _fmemset

-#else /* Use the usual functions */

-#  define CVT_PTR(ptr)         (ptr)

-#  define CVT_PTR_NOCHECK(ptr) (ptr)

-#  ifndef PNG_NO_SNPRINTF

-#    ifdef _MSC_VER

-#      define png_snprintf _snprintf   /* Added to v 1.2.19 */

-#      define png_snprintf2 _snprintf

-#      define png_snprintf6 _snprintf

-#    else

-#      define png_snprintf snprintf   /* Added to v 1.2.19 */

-#      define png_snprintf2 snprintf

-#      define png_snprintf6 snprintf

-#    endif

-#  else

-     /* You don't have or don't want to use snprintf().  Caution: Using

-      * sprintf instead of snprintf exposes your application to accidental

-      * or malevolent buffer overflows.  If you don't have snprintf()

-      * as a general rule you should provide one (you can get one from

-      * Portable OpenSSH).

-      */

-#    define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1)

-#    define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2)

-#    define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \

-        sprintf(s1,fmt,x1,x2,x3,x4,x5,x6)

-#  endif

-#  define png_strlen  strlen

-#  define png_memcmp  memcmp      /* SJT: added */

-#  define png_memcpy  memcpy

-#  define png_memset  memset

-#endif

-/* End of memory model independent support */

-

-/* Just a little check that someone hasn't tried to define something

- * contradictory.

- */

-#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)

-#  undef PNG_ZBUF_SIZE

-#  define PNG_ZBUF_SIZE 65536L

-#endif

-

-/* Added at libpng-1.2.8 */

-#endif /* PNG_VERSION_INFO_ONLY */

-

-#endif /* PNGCONF_H */

+
+/* pngconf.h - machine configurable file for libpng
+ *
+ * libpng version 1.4.0 - January 3, 2010
+ * For conditions of distribution and use, see copyright notice in png.h
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ */
+
+/* Any machine specific code is near the front of this file, so if you
+ * are configuring libpng for a machine, you may want to read the section
+ * starting here down to where it starts to typedef png_color, png_text,
+ * and png_info.
+ */
+
+#ifndef PNGCONF_H
+#define PNGCONF_H
+
+#ifndef PNG_NO_LIMITS_H
+#  include <limits.h>
+#endif
+
+/* Added at libpng-1.2.9 */
+
+/* config.h is created by and PNG_CONFIGURE_LIBPNG is set by the "configure" script. */
+#ifdef PNG_CONFIGURE_LIBPNG
+#  ifdef HAVE_CONFIG_H
+#    include "config.h"
+#  endif
+#endif
+
+/*
+ * Added at libpng-1.2.8
+ *
+ * PNG_USER_CONFIG has to be defined on the compiler command line. This
+ * includes the resource compiler for Windows DLL configurations.
+ */
+#ifdef PNG_USER_CONFIG
+#  ifndef PNG_USER_PRIVATEBUILD
+#    define PNG_USER_PRIVATEBUILD
+#  endif
+#  include "pngusr.h"
+#endif
+
+/*
+ * If you create a private DLL you need to define in "pngusr.h" the followings:
+ * #define PNG_USER_PRIVATEBUILD <Describes by whom and why this version of
+ *        the DLL was built>
+ *  e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons."
+ * #define PNG_USER_DLLFNAME_POSTFIX <two-letter postfix that serve to
+ *        distinguish your DLL from those of the official release. These
+ *        correspond to the trailing letters that come after the version
+ *        number and must match your private DLL name>
+ *  e.g. // private DLL "libpng13gx.dll"
+ *       #define PNG_USER_DLLFNAME_POSTFIX "gx"
+ *
+ * The following macros are also at your disposal if you want to complete the
+ * DLL VERSIONINFO structure.
+ * - PNG_USER_VERSIONINFO_COMMENTS
+ * - PNG_USER_VERSIONINFO_COMPANYNAME
+ * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS
+ */
+
+#ifdef __STDC__
+#  ifdef SPECIALBUILD
+#    pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\
+     are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.")
+#  endif
+
+#  ifdef PRIVATEBUILD
+#    pragma message("PRIVATEBUILD is deprecated.\
+     Use PNG_USER_PRIVATEBUILD instead.")
+#    define PNG_USER_PRIVATEBUILD PRIVATEBUILD
+#  endif
+#endif /* __STDC__ */
+
+/* End of material added to libpng-1.2.8 */
+
+#ifndef PNG_VERSION_INFO_ONLY
+
+/* This is the size of the compression buffer, and thus the size of
+ * an IDAT chunk.  Make this whatever size you feel is best for your
+ * machine.  One of these will be allocated per png_struct.  When this
+ * is full, it writes the data to the disk, and does some other
+ * calculations.  Making this an extremely small size will slow
+ * the library down, but you may want to experiment to determine
+ * where it becomes significant, if you are concerned with memory
+ * usage.  Note that zlib allocates at least 32Kb also.  For readers,
+ * this describes the size of the buffer available to read the data in.
+ * Unless this gets smaller than the size of a row (compressed),
+ * it should not make much difference how big this is.
+ */
+
+#ifndef PNG_ZBUF_SIZE
+#  define PNG_ZBUF_SIZE 8192
+#endif
+
+/* Enable if you want a write-only libpng */
+
+#ifndef PNG_NO_READ_SUPPORTED
+#  define PNG_READ_SUPPORTED
+#endif
+
+/* Enable if you want a read-only libpng */
+
+#ifndef PNG_NO_WRITE_SUPPORTED
+#  define PNG_WRITE_SUPPORTED
+#endif
+
+/* Enabled in 1.4.0. */
+#ifdef PNG_ALLOW_BENIGN_ERRORS
+#  define png_benign_error png_warning
+#  define png_chunk_benign_error png_chunk_warning
+#else
+#  ifndef PNG_BENIGN_ERRORS_SUPPORTED
+#    define png_benign_error png_error
+#    define png_chunk_benign_error png_chunk_error
+#  endif
+#endif
+
+/* Added at libpng version 1.4.0 */
+#if !defined(PNG_NO_WARNINGS) && !defined(PNG_WARNINGS_SUPPORTED)
+#  define PNG_WARNINGS_SUPPORTED
+#endif
+
+/* Added at libpng version 1.4.0 */
+#if !defined(PNG_NO_ERROR_TEXT) && !defined(PNG_ERROR_TEXT_SUPPORTED)
+#  define PNG_ERROR_TEXT_SUPPORTED
+#endif
+
+/* Added at libpng version 1.4.0 */
+#if !defined(PNG_NO_CHECK_cHRM) && !defined(PNG_CHECK_cHRM_SUPPORTED)
+#  define PNG_CHECK_cHRM_SUPPORTED
+#endif
+
+/* Added at libpng version 1.4.0 */
+#if !defined(PNG_NO_ALIGNED_MEMORY) && !defined(PNG_ALIGNED_MEMORY_SUPPORTED)
+#  define PNG_ALIGNED_MEMORY_SUPPORTED
+#endif
+
+/* Enabled by default in 1.2.0.  You can disable this if you don't need to
+   support PNGs that are embedded in MNG datastreams */
+#ifndef PNG_NO_MNG_FEATURES
+#  ifndef PNG_MNG_FEATURES_SUPPORTED
+#    define PNG_MNG_FEATURES_SUPPORTED
+#  endif
+#endif
+
+/* Added at libpng version 1.4.0 */
+#ifndef PNG_NO_FLOATING_POINT_SUPPORTED
+#  ifndef PNG_FLOATING_POINT_SUPPORTED
+#    define PNG_FLOATING_POINT_SUPPORTED
+#  endif
+#endif
+
+/* Added at libpng-1.4.0beta49 for testing (this test is no longer used
+   in libpng and png_calloc() is always present)
+ */
+#define PNG_CALLOC_SUPPORTED
+
+/* If you are running on a machine where you cannot allocate more
+ * than 64K of memory at once, uncomment this.  While libpng will not
+ * normally need that much memory in a chunk (unless you load up a very
+ * large file), zlib needs to know how big of a chunk it can use, and
+ * libpng thus makes sure to check any memory allocation to verify it
+ * will fit into memory.
+#define PNG_MAX_MALLOC_64K
+ */
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
+#  define PNG_MAX_MALLOC_64K
+#endif
+
+/* Special munging to support doing things the 'cygwin' way:
+ * 'Normal' png-on-win32 defines/defaults:
+ *   PNG_BUILD_DLL -- building dll
+ *   PNG_USE_DLL   -- building an application, linking to dll
+ *   (no define)   -- building static library, or building an
+ *                    application and linking to the static lib
+ * 'Cygwin' defines/defaults:
+ *   PNG_BUILD_DLL -- (ignored) building the dll
+ *   (no define)   -- (ignored) building an application, linking to the dll
+ *   PNG_STATIC    -- (ignored) building the static lib, or building an
+ *                    application that links to the static lib.
+ *   ALL_STATIC    -- (ignored) building various static libs, or building an
+ *                    application that links to the static libs.
+ * Thus,
+ * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and
+ * this bit of #ifdefs will define the 'correct' config variables based on
+ * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but
+ * unnecessary.
+ *
+ * Also, the precedence order is:
+ *   ALL_STATIC (since we can't #undef something outside our namespace)
+ *   PNG_BUILD_DLL
+ *   PNG_STATIC
+ *   (nothing) == PNG_USE_DLL
+ *
+ * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent
+ *   of auto-import in binutils, we no longer need to worry about
+ *   __declspec(dllexport) / __declspec(dllimport) and friends.  Therefore,
+ *   we don't need to worry about PNG_STATIC or ALL_STATIC when it comes
+ *   to __declspec() stuff.  However, we DO need to worry about
+ *   PNG_BUILD_DLL and PNG_STATIC because those change some defaults
+ *   such as CONSOLE_IO.
+ */
+#ifdef __CYGWIN__
+#  ifdef ALL_STATIC
+#    ifdef PNG_BUILD_DLL
+#      undef PNG_BUILD_DLL
+#    endif
+#    ifdef PNG_USE_DLL
+#      undef PNG_USE_DLL
+#    endif
+#    ifdef PNG_DLL
+#      undef PNG_DLL
+#    endif
+#    ifndef PNG_STATIC
+#      define PNG_STATIC
+#    endif
+#  else
+#    ifdef PNG_BUILD_DLL
+#      ifdef PNG_STATIC
+#        undef PNG_STATIC
+#      endif
+#      ifdef PNG_USE_DLL
+#        undef PNG_USE_DLL
+#      endif
+#      ifndef PNG_DLL
+#        define PNG_DLL
+#      endif
+#    else
+#      ifdef PNG_STATIC
+#        ifdef PNG_USE_DLL
+#          undef PNG_USE_DLL
+#        endif
+#        ifdef PNG_DLL
+#          undef PNG_DLL
+#        endif
+#      else
+#        ifndef PNG_USE_DLL
+#          define PNG_USE_DLL
+#        endif
+#        ifndef PNG_DLL
+#          define PNG_DLL
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* This protects us against compilers that run on a windowing system
+ * and thus don't have or would rather us not use the stdio types:
+ * stdin, stdout, and stderr.  The only one currently used is stderr
+ * in png_error() and png_warning().  #defining PNG_NO_CONSOLE_IO will
+ * prevent these from being compiled and used. #defining PNG_NO_STDIO
+ * will also prevent these, plus will prevent the entire set of stdio
+ * macros and functions (FILE *, printf, etc.) from being compiled and used,
+ * unless (PNG_DEBUG > 0) has been #defined.
+ *
+ * #define PNG_NO_CONSOLE_IO
+ * #define PNG_NO_STDIO
+ */
+
+#if !defined(PNG_NO_STDIO) && !defined(PNG_STDIO_SUPPORTED)
+#  define PNG_STDIO_SUPPORTED
+#endif
+
+
+#ifdef PNG_BUILD_DLL
+#  if !defined(PNG_CONSOLE_IO_SUPPORTED) && !defined(PNG_NO_CONSOLE_IO)
+#    define PNG_NO_CONSOLE_IO
+#  endif
+#endif
+
+#  ifdef PNG_NO_STDIO
+#    ifndef PNG_NO_CONSOLE_IO
+#      define PNG_NO_CONSOLE_IO
+#    endif
+#    ifdef PNG_DEBUG
+#      if (PNG_DEBUG > 0)
+#        include <stdio.h>
+#      endif
+#    endif
+#  else
+#    include <stdio.h>
+#  endif
+
+#if !(defined PNG_NO_CONSOLE_IO) && !defined(PNG_CONSOLE_IO_SUPPORTED)
+#  define PNG_CONSOLE_IO_SUPPORTED
+#endif
+
+/* This macro protects us against machines that don't have function
+ * prototypes (ie K&R style headers).  If your compiler does not handle
+ * function prototypes, define this macro and use the included ansi2knr.
+ * I've always been able to use _NO_PROTO as the indicator, but you may
+ * need to drag the empty declaration out in front of here, or change the
+ * ifdef to suit your own needs.
+ */
+#ifndef PNGARG
+
+#ifdef OF /* zlib prototype munger */
+#  define PNGARG(arglist) OF(arglist)
+#else
+
+#ifdef _NO_PROTO
+#  define PNGARG(arglist) ()
+#else
+#  define PNGARG(arglist) arglist
+#endif /* _NO_PROTO */
+
+#endif /* OF */
+
+#endif /* PNGARG */
+
+/* Try to determine if we are compiling on a Mac.  Note that testing for
+ * just __MWERKS__ is not good enough, because the Codewarrior is now used
+ * on non-Mac platforms.
+ */
+#ifndef MACOS
+#  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
+      defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
+#    define MACOS
+#  endif
+#endif
+
+/* Enough people need this for various reasons to include it here */
+#if !defined(MACOS) && !defined(RISCOS)
+#  include <sys/types.h>
+#endif
+
+/* PNG_SETJMP_NOT_SUPPORTED and PNG_NO_SETJMP_SUPPORTED are deprecated. */
+#if !defined(PNG_NO_SETJMP) && \
+    !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED)
+#  define PNG_SETJMP_SUPPORTED
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* This is an attempt to force a single setjmp behaviour on Linux.  If
+ * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
+ *
+ * You can bypass this test if you know that your application uses exactly
+ * the same setjmp.h that was included when libpng was built.  Only define
+ * PNG_SKIP_SETJMP_CHECK while building your application, prior to the
+ * application's '#include "png.h"'. Don't define PNG_SKIP_SETJMP_CHECK
+ * while building a separate libpng library for general use.
+ */
+
+#  ifndef PNG_SKIP_SETJMP_CHECK
+#    ifdef __linux__
+#      ifdef _BSD_SOURCE
+#        define PNG_SAVE_BSD_SOURCE
+#        undef _BSD_SOURCE
+#      endif
+#      ifdef _SETJMP_H
+       /* If you encounter a compiler error here, see the explanation
+        * near the end of INSTALL.
+        */
+           __pngconf.h__ in libpng already includes setjmp.h;
+           __dont__ include it again.;
+#      endif
+#    endif /* __linux__ */
+#  endif /* PNG_SKIP_SETJMP_CHECK */
+
+   /* Include setjmp.h for error handling */
+#  include <setjmp.h>
+
+#  ifdef __linux__
+#    ifdef PNG_SAVE_BSD_SOURCE
+#      ifdef _BSD_SOURCE
+#        undef _BSD_SOURCE
+#      endif
+#      define _BSD_SOURCE
+#      undef PNG_SAVE_BSD_SOURCE
+#    endif
+#  endif /* __linux__ */
+#endif /* PNG_SETJMP_SUPPORTED */
+
+#ifdef BSD
+#  include <strings.h>
+#else
+#  include <string.h>
+#endif
+
+/* Other defines for things like memory and the like can go here.  */
+
+/* This controls how fine the dithering gets.  As this allocates
+ * a largish chunk of memory (32K), those who are not as concerned
+ * with dithering quality can decrease some or all of these.
+ */
+#ifndef PNG_DITHER_RED_BITS
+#  define PNG_DITHER_RED_BITS 5
+#endif
+#ifndef PNG_DITHER_GREEN_BITS
+#  define PNG_DITHER_GREEN_BITS 5
+#endif
+#ifndef PNG_DITHER_BLUE_BITS
+#  define PNG_DITHER_BLUE_BITS 5
+#endif
+
+/* This controls how fine the gamma correction becomes when you
+ * are only interested in 8 bits anyway.  Increasing this value
+ * results in more memory being used, and more pow() functions
+ * being called to fill in the gamma tables.  Don't set this value
+ * less then 8, and even that may not work (I haven't tested it).
+ */
+
+#ifndef PNG_MAX_GAMMA_8
+#  define PNG_MAX_GAMMA_8 11
+#endif
+
+/* This controls how much a difference in gamma we can tolerate before
+ * we actually start doing gamma conversion.
+ */
+#ifndef PNG_GAMMA_THRESHOLD
+#  define PNG_GAMMA_THRESHOLD 0.05
+#endif
+
+/* The following uses const char * instead of char * for error
+ * and warning message functions, so some compilers won't complain.
+ * If you do not want to use const, define PNG_NO_CONST here.
+ */
+
+#ifndef PNG_CONST
+#  ifndef PNG_NO_CONST
+#    define PNG_CONST const
+#  else
+#    define PNG_CONST
+#  endif
+#endif
+
+/* The following defines give you the ability to remove code from the
+ * library that you will not be using.  I wish I could figure out how to
+ * automate this, but I can't do that without making it seriously hard
+ * on the users.  So if you are not using an ability, change the #define
+ * to and #undef, and that part of the library will not be compiled.  If
+ * your linker can't find a function, you may want to make sure the
+ * ability is defined here.  Some of these depend upon some others being
+ * defined.  I haven't figured out all the interactions here, so you may
+ * have to experiment awhile to get everything to compile.  If you are
+ * creating or using a shared library, you probably shouldn't touch this,
+ * as it will affect the size of the structures, and this will cause bad
+ * things to happen if the library and/or application ever change.
+ */
+
+/* Any features you will not be using can be undef'ed here */
+
+/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user
+ * to turn it off with PNG_NO_READ|WRITE_TRANSFORMS on the compile line,
+ * then pick and choose which ones to define without having to edit this
+ * file. It is safe to use the PNG_NO_READ|WRITE_TRANSFORMS
+ * if you only want to have a png-compliant reader/writer but don't need
+ * any of the extra transformations.  This saves about 80 kbytes in a
+ * typical installation of the library. (PNG_NO_* form added in version
+ * 1.0.1c, for consistency; PNG_*_TRANSFORMS_NOT_SUPPORTED deprecated in
+ * 1.4.0)
+ */
+
+/* Ignore attempt to turn off both floating and fixed point support */
+#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \
+    !defined(PNG_NO_FIXED_POINT_SUPPORTED)
+#  define PNG_FIXED_POINT_SUPPORTED
+#endif
+
+#ifdef PNG_READ_SUPPORTED
+
+/* PNG_READ_TRANSFORMS_NOT_SUPPORTED is deprecated. */
+#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \
+      !defined(PNG_NO_READ_TRANSFORMS)
+#  define PNG_READ_TRANSFORMS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+#  ifndef PNG_NO_READ_EXPAND
+#    define PNG_READ_EXPAND_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_SHIFT
+#    define PNG_READ_SHIFT_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_PACK
+#    define PNG_READ_PACK_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_BGR
+#    define PNG_READ_BGR_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_SWAP
+#    define PNG_READ_SWAP_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_PACKSWAP
+#    define PNG_READ_PACKSWAP_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_INVERT
+#    define PNG_READ_INVERT_SUPPORTED
+#  endif
+#if 0 /* removed from libpng-1.4.0 */
+#  ifndef PNG_NO_READ_DITHER
+#    define PNG_READ_DITHER_SUPPORTED
+#  endif
+#endif /* 0 */
+#  ifndef PNG_NO_READ_BACKGROUND
+#    define PNG_READ_BACKGROUND_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_16_TO_8
+#    define PNG_READ_16_TO_8_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_FILLER
+#    define PNG_READ_FILLER_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_GAMMA
+#    define PNG_READ_GAMMA_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_GRAY_TO_RGB
+#    define PNG_READ_GRAY_TO_RGB_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_SWAP_ALPHA
+#    define PNG_READ_SWAP_ALPHA_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_INVERT_ALPHA
+#    define PNG_READ_INVERT_ALPHA_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_STRIP_ALPHA
+#    define PNG_READ_STRIP_ALPHA_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_USER_TRANSFORM
+#    define PNG_READ_USER_TRANSFORM_SUPPORTED
+#  endif
+#  ifndef PNG_NO_READ_RGB_TO_GRAY
+#    define PNG_READ_RGB_TO_GRAY_SUPPORTED
+#  endif
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+/* PNG_PROGRESSIVE_READ_NOT_SUPPORTED is deprecated. */
+#if !defined(PNG_NO_PROGRESSIVE_READ) && \
+ !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED)  /* if you don't do progressive */
+#  define PNG_PROGRESSIVE_READ_SUPPORTED     /* reading.  This is not talking */
+#endif                               /* about interlacing capability!  You'll */
+            /* still have interlacing unless you change the following define: */
+
+#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */
+
+/* PNG_NO_SEQUENTIAL_READ_SUPPORTED is deprecated. */
+#if !defined(PNG_NO_SEQUENTIAL_READ) && \
+    !defined(PNG_SEQUENTIAL_READ_SUPPORTED) && \
+    !defined(PNG_NO_SEQUENTIAL_READ_SUPPORTED)
+#  define PNG_SEQUENTIAL_READ_SUPPORTED
+#endif
+
+#ifndef PNG_NO_READ_COMPOSITE_NODIV
+#  ifndef PNG_NO_READ_COMPOSITED_NODIV  /* libpng-1.0.x misspelling */
+#    define PNG_READ_COMPOSITE_NODIV_SUPPORTED   /* well tested on Intel, SGI */
+#  endif
+#endif
+
+#if !defined(PNG_NO_GET_INT_32) || defined(PNG_READ_oFFS_SUPPORTED) || \
+    defined(PNG_READ_pCAL_SUPPORTED)
+#  ifndef PNG_GET_INT_32_SUPPORTED
+#    define PNG_GET_INT_32_SUPPORTED
+#  endif
+#endif
+
+#endif /* PNG_READ_SUPPORTED */
+
+#ifdef PNG_WRITE_SUPPORTED
+
+/* PNG_WRITE_TRANSFORMS_NOT_SUPPORTED is deprecated. */
+#if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_TRANSFORMS)
+#  define PNG_WRITE_TRANSFORMS_SUPPORTED
+#endif
+
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+#  ifndef PNG_NO_WRITE_SHIFT
+#    define PNG_WRITE_SHIFT_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_PACK
+#    define PNG_WRITE_PACK_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_BGR
+#    define PNG_WRITE_BGR_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_SWAP
+#    define PNG_WRITE_SWAP_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_PACKSWAP
+#    define PNG_WRITE_PACKSWAP_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_INVERT
+#    define PNG_WRITE_INVERT_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_FILLER
+#    define PNG_WRITE_FILLER_SUPPORTED   /* same as WRITE_STRIP_ALPHA */
+#  endif
+#  ifndef PNG_NO_WRITE_SWAP_ALPHA
+#    define PNG_WRITE_SWAP_ALPHA_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_INVERT_ALPHA
+#    define PNG_WRITE_INVERT_ALPHA_SUPPORTED
+#  endif
+#  ifndef PNG_NO_WRITE_USER_TRANSFORM
+#    define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+#  endif
+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */
+
+#if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \
+    !defined(PNG_WRITE_INTERLACING_SUPPORTED)
+    /* This is not required for PNG-compliant encoders, but can cause
+     * trouble if left undefined
+    */
+#  define PNG_WRITE_INTERLACING_SUPPORTED
+#endif
+
+#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \
+    !defined(PNG_WRITE_WEIGHTED_FILTER) && \
+     defined(PNG_FLOATING_POINT_SUPPORTED)
+#  define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#endif
+
+#ifndef PNG_NO_WRITE_FLUSH
+#  define PNG_WRITE_FLUSH_SUPPORTED
+#endif
+
+#if !defined(PNG_NO_SAVE_INT_32) || defined(PNG_WRITE_oFFS_SUPPORTED) || \
+    defined(PNG_WRITE_pCAL_SUPPORTED)
+#  ifndef PNG_SAVE_INT_32_SUPPORTED
+#    define PNG_SAVE_INT_32_SUPPORTED
+#  endif
+#endif
+
+#endif /* PNG_WRITE_SUPPORTED */
+
+#define PNG_NO_ERROR_NUMBERS
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+#  ifndef PNG_NO_USER_TRANSFORM_PTR
+#    define PNG_USER_TRANSFORM_PTR_SUPPORTED
+#  endif
+#endif
+
+#if defined(PNG_STDIO_SUPPORTED) && !defined(PNG_TIME_RFC1123_SUPPORTED)
+#  define PNG_TIME_RFC1123_SUPPORTED
+#endif
+
+/* This adds extra functions in pngget.c for accessing data from the
+ * info pointer (added in version 0.99)
+ * png_get_image_width()
+ * png_get_image_height()
+ * png_get_bit_depth()
+ * png_get_color_type()
+ * png_get_compression_type()
+ * png_get_filter_type()
+ * png_get_interlace_type()
+ * png_get_pixel_aspect_ratio()
+ * png_get_pixels_per_meter()
+ * png_get_x_offset_pixels()
+ * png_get_y_offset_pixels()
+ * png_get_x_offset_microns()
+ * png_get_y_offset_microns()
+ */
+#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED)
+#  define PNG_EASY_ACCESS_SUPPORTED
+#endif
+
+/* Added at libpng-1.2.0 */
+#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED)
+#  define PNG_USER_MEM_SUPPORTED
+#endif
+
+/* Added at libpng-1.2.6 */
+#ifndef PNG_SET_USER_LIMITS_SUPPORTED
+#  ifndef PNG_NO_SET_USER_LIMITS
+#    define PNG_SET_USER_LIMITS_SUPPORTED
+#  endif
+#endif
+
+/* Added at libpng-1.0.16 and 1.2.6.  To accept all valid PNGs no matter
+ * how large, set these limits to 0x7fffffffL
+ */
+#ifndef PNG_USER_WIDTH_MAX
+#  define PNG_USER_WIDTH_MAX 1000000L
+#endif
+#ifndef PNG_USER_HEIGHT_MAX
+#  define PNG_USER_HEIGHT_MAX 1000000L
+#endif
+
+/* Added at libpng-1.4.0 */
+#ifndef PNG_USER_CHUNK_CACHE_MAX
+#  define PNG_USER_CHUNK_CACHE_MAX 0x7fffffffL
+#endif
+
+/* Added at libpng-1.4.0 */
+#if !defined(PNG_NO_IO_STATE) && !defined(PNG_IO_STATE_SUPPORTED)
+#  define PNG_IO_STATE_SUPPORTED
+#endif
+
+#ifndef PNG_LITERAL_SHARP
+#  define PNG_LITERAL_SHARP 0x23
+#endif
+#ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET
+#  define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b
+#endif
+#ifndef PNG_LITERAL_RIGHT_SQUARE_BRACKET
+#  define PNG_LITERAL_RIGHT_SQUARE_BRACKET 0x5d
+#endif
+#ifndef PNG_STRING_NEWLINE
+#define PNG_STRING_NEWLINE "\n"
+#endif
+
+/* These are currently experimental features, define them if you want */
+
+/* Very little testing */
+/*
+#ifdef PNG_READ_SUPPORTED
+#  ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+#    define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+#  endif
+#endif
+*/
+
+/* This is only for PowerPC big-endian and 680x0 systems */
+/* some testing */
+/*
+#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED
+#  define PNG_READ_BIG_ENDIAN_SUPPORTED
+#endif
+*/
+
+#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS)
+#  define PNG_USE_READ_MACROS
+#endif
+
+/* Buggy compilers (e.g., gcc 2.7.2.2) need PNG_NO_POINTER_INDEXING */
+
+#if !defined(PNG_NO_POINTER_INDEXING) && \
+    !defined(PNG_POINTER_INDEXING_SUPPORTED)
+#  define PNG_POINTER_INDEXING_SUPPORTED
+#endif
+
+
+/* Any chunks you are not interested in, you can undef here.  The
+ * ones that allocate memory may be expecially important (hIST,
+ * tEXt, zTXt, tRNS, pCAL).  Others will just save time and make png_info
+ * a bit smaller.
+ */
+
+/* The size of the png_text structure changed in libpng-1.0.6 when
+ * iTXt support was added.  iTXt support was turned off by default through
+ * libpng-1.2.x, to support old apps that malloc the png_text structure
+ * instead of calling png_set_text() and letting libpng malloc it.  It
+ * was turned on by default in libpng-1.4.0.
+ */
+
+/* PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED is deprecated. */
+#if defined(PNG_READ_SUPPORTED) && \
+    !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_READ_ANCILLARY_CHUNKS)
+#  define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+
+/* PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED is deprecated. */
+#if defined(PNG_WRITE_SUPPORTED) && \
+    !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \
+    !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)
+#  define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#endif
+
+#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+
+#ifdef PNG_NO_READ_TEXT
+#  define PNG_NO_READ_iTXt
+#  define PNG_NO_READ_tEXt
+#  define PNG_NO_READ_zTXt
+#endif
+
+#ifndef PNG_NO_READ_bKGD
+#  define PNG_READ_bKGD_SUPPORTED
+#  define PNG_bKGD_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_cHRM
+#  define PNG_READ_cHRM_SUPPORTED
+#  define PNG_cHRM_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_gAMA
+#  define PNG_READ_gAMA_SUPPORTED
+#  define PNG_gAMA_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_hIST
+#  define PNG_READ_hIST_SUPPORTED
+#  define PNG_hIST_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_iCCP
+#  define PNG_READ_iCCP_SUPPORTED
+#  define PNG_iCCP_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_iTXt
+#  ifndef PNG_READ_iTXt_SUPPORTED
+#    define PNG_READ_iTXt_SUPPORTED
+#  endif
+#  ifndef PNG_iTXt_SUPPORTED
+#    define PNG_iTXt_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_READ_oFFs
+#  define PNG_READ_oFFs_SUPPORTED
+#  define PNG_oFFs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pCAL
+#  define PNG_READ_pCAL_SUPPORTED
+#  define PNG_pCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sCAL
+#  define PNG_READ_sCAL_SUPPORTED
+#  define PNG_sCAL_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_pHYs
+#  define PNG_READ_pHYs_SUPPORTED
+#  define PNG_pHYs_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sBIT
+#  define PNG_READ_sBIT_SUPPORTED
+#  define PNG_sBIT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sPLT
+#  define PNG_READ_sPLT_SUPPORTED
+#  define PNG_sPLT_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_sRGB
+#  define PNG_READ_sRGB_SUPPORTED
+#  define PNG_sRGB_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tEXt
+#  define PNG_READ_tEXt_SUPPORTED
+#  define PNG_tEXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tIME
+#  define PNG_READ_tIME_SUPPORTED
+#  define PNG_tIME_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_tRNS
+#  define PNG_READ_tRNS_SUPPORTED
+#  define PNG_tRNS_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_zTXt
+#  define PNG_READ_zTXt_SUPPORTED
+#  define PNG_zTXt_SUPPORTED
+#endif
+#ifndef PNG_NO_READ_OPT_PLTE
+#  define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */
+#endif                      /* optional PLTE chunk in RGB and RGBA images */
+#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \
+    defined(PNG_READ_zTXt_SUPPORTED)
+#  define PNG_READ_TEXT_SUPPORTED
+#  define PNG_TEXT_SUPPORTED
+#endif
+
+#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */
+
+#ifndef PNG_NO_READ_UNKNOWN_CHUNKS
+#  define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED
+#    define PNG_UNKNOWN_CHUNKS_SUPPORTED
+#  endif
+#endif
+#if !defined(PNG_NO_READ_USER_CHUNKS) && \
+     defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
+#  define PNG_READ_USER_CHUNKS_SUPPORTED
+#  define PNG_USER_CHUNKS_SUPPORTED
+#  ifdef PNG_NO_READ_UNKNOWN_CHUNKS
+#    undef PNG_NO_READ_UNKNOWN_CHUNKS
+#  endif
+#  ifdef PNG_NO_HANDLE_AS_UNKNOWN
+#    undef PNG_NO_HANDLE_AS_UNKNOWN
+#  endif
+#endif
+#ifndef PNG_NO_HANDLE_AS_UNKNOWN
+#  ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#    define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#  endif
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+
+#ifdef PNG_NO_WRITE_TEXT
+#  define PNG_NO_WRITE_iTXt
+#  define PNG_NO_WRITE_tEXt
+#  define PNG_NO_WRITE_zTXt
+#endif
+#ifndef PNG_NO_WRITE_bKGD
+#  define PNG_WRITE_bKGD_SUPPORTED
+#  ifndef PNG_bKGD_SUPPORTED
+#    define PNG_bKGD_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_cHRM
+#  define PNG_WRITE_cHRM_SUPPORTED
+#  ifndef PNG_cHRM_SUPPORTED
+#    define PNG_cHRM_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_gAMA
+#  define PNG_WRITE_gAMA_SUPPORTED
+#  ifndef PNG_gAMA_SUPPORTED
+#    define PNG_gAMA_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_hIST
+#  define PNG_WRITE_hIST_SUPPORTED
+#  ifndef PNG_hIST_SUPPORTED
+#    define PNG_hIST_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_iCCP
+#  define PNG_WRITE_iCCP_SUPPORTED
+#  ifndef PNG_iCCP_SUPPORTED
+#    define PNG_iCCP_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_iTXt
+#  ifndef PNG_WRITE_iTXt_SUPPORTED
+#    define PNG_WRITE_iTXt_SUPPORTED
+#  endif
+#  ifndef PNG_iTXt_SUPPORTED
+#    define PNG_iTXt_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_oFFs
+#  define PNG_WRITE_oFFs_SUPPORTED
+#  ifndef PNG_oFFs_SUPPORTED
+#    define PNG_oFFs_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_pCAL
+#  define PNG_WRITE_pCAL_SUPPORTED
+#  ifndef PNG_pCAL_SUPPORTED
+#    define PNG_pCAL_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_sCAL
+#  define PNG_WRITE_sCAL_SUPPORTED
+#  ifndef PNG_sCAL_SUPPORTED
+#    define PNG_sCAL_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_pHYs
+#  define PNG_WRITE_pHYs_SUPPORTED
+#  ifndef PNG_pHYs_SUPPORTED
+#    define PNG_pHYs_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_sBIT
+#  define PNG_WRITE_sBIT_SUPPORTED
+#  ifndef PNG_sBIT_SUPPORTED
+#    define PNG_sBIT_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_sPLT
+#  define PNG_WRITE_sPLT_SUPPORTED
+#  ifndef PNG_sPLT_SUPPORTED
+#    define PNG_sPLT_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_sRGB
+#  define PNG_WRITE_sRGB_SUPPORTED
+#  ifndef PNG_sRGB_SUPPORTED
+#    define PNG_sRGB_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_tEXt
+#  define PNG_WRITE_tEXt_SUPPORTED
+#  ifndef PNG_tEXt_SUPPORTED
+#    define PNG_tEXt_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_tIME
+#  define PNG_WRITE_tIME_SUPPORTED
+#  ifndef PNG_tIME_SUPPORTED
+#    define PNG_tIME_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_tRNS
+#  define PNG_WRITE_tRNS_SUPPORTED
+#  ifndef PNG_tRNS_SUPPORTED
+#    define PNG_tRNS_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_WRITE_zTXt
+#  define PNG_WRITE_zTXt_SUPPORTED
+#  ifndef PNG_zTXt_SUPPORTED
+#    define PNG_zTXt_SUPPORTED
+#  endif
+#endif
+#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \
+    defined(PNG_WRITE_zTXt_SUPPORTED)
+#  define PNG_WRITE_TEXT_SUPPORTED
+#  ifndef PNG_TEXT_SUPPORTED
+#    define PNG_TEXT_SUPPORTED
+#  endif
+#endif
+
+#ifdef PNG_WRITE_tIME_SUPPORTED
+#  ifndef PNG_NO_CONVERT_tIME
+#    ifndef _WIN32_WCE
+/*   The "tm" structure is not supported on WindowsCE */
+#      ifndef PNG_CONVERT_tIME_SUPPORTED
+#        define PNG_CONVERT_tIME_SUPPORTED
+#      endif
+#   endif
+#  endif
+#endif
+
+#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */
+
+#if !defined(PNG_NO_WRITE_FILTER) && !defined(PNG_WRITE_FILTER_SUPPORTED)
+#  define PNG_WRITE_FILTER_SUPPORTED
+#endif
+
+#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS
+#  define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED
+#    define PNG_UNKNOWN_CHUNKS_SUPPORTED
+#  endif
+#endif
+#ifndef PNG_NO_HANDLE_AS_UNKNOWN
+#  ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#    define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#  endif
+#endif
+#endif /* PNG_WRITE_SUPPORTED */
+
+/* Turn this off to disable png_read_png() and
+ * png_write_png() and leave the row_pointers member
+ * out of the info structure.
+ */
+#ifndef PNG_NO_INFO_IMAGE
+#  define PNG_INFO_IMAGE_SUPPORTED
+#endif
+
+/* Need the time information for converting tIME chunks */
+#ifdef PNG_CONVERT_tIME_SUPPORTED
+     /* "time.h" functions are not supported on WindowsCE */
+#    include <time.h>
+#endif
+
+/* Some typedefs to get us started.  These should be safe on most of the
+ * common platforms.  The typedefs should be at least as large as the
+ * numbers suggest (a png_uint_32 must be at least 32 bits long), but they
+ * don't have to be exactly that size.  Some compilers dislike passing
+ * unsigned shorts as function parameters, so you may be better off using
+ * unsigned int for png_uint_16.
+ */
+
+#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL)
+typedef unsigned int png_uint_32;
+typedef int png_int_32;
+#else
+typedef unsigned long png_uint_32;
+typedef long png_int_32;
+#endif
+typedef unsigned short png_uint_16;
+typedef short png_int_16;
+typedef unsigned char png_byte;
+
+#ifdef PNG_NO_SIZE_T
+   typedef unsigned int png_size_t;
+#else
+   typedef size_t png_size_t;
+#endif
+#define png_sizeof(x) sizeof(x)
+
+/* The following is needed for medium model support.  It cannot be in the
+ * pngpriv.h header.  Needs modification for other compilers besides
+ * MSC.  Model independent support declares all arrays and pointers to be
+ * large using the far keyword.  The zlib version used must also support
+ * model independent data.  As of version zlib 1.0.4, the necessary changes
+ * have been made in zlib.  The USE_FAR_KEYWORD define triggers other
+ * changes that are needed. (Tim Wegner)
+ */
+
+/* Separate compiler dependencies (problem here is that zlib.h always
+ * defines FAR. (SJT)
+ */
+#ifdef __BORLANDC__
+#  if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)
+#    define LDATA 1
+#  else
+#    define LDATA 0
+#  endif
+   /* GRR:  why is Cygwin in here?  Cygwin is not Borland C... */
+#  if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)
+#    define PNG_MAX_MALLOC_64K
+#    if (LDATA != 1)
+#      ifndef FAR
+#        define FAR __far
+#      endif
+#      define USE_FAR_KEYWORD
+#    endif   /* LDATA != 1 */
+     /* Possibly useful for moving data out of default segment.
+      * Uncomment it if you want. Could also define FARDATA as
+      * const if your compiler supports it. (SJT)
+#    define FARDATA FAR
+      */
+#  endif  /* __WIN32__, __FLAT__, __CYGWIN__ */
+#endif   /* __BORLANDC__ */
+
+
+/* Suggest testing for specific compiler first before testing for
+ * FAR.  The Watcom compiler defines both __MEDIUM__ and M_I86MM,
+ * making reliance oncertain keywords suspect. (SJT)
+ */
+
+/* MSC Medium model */
+#ifdef FAR
+#  ifdef M_I86MM
+#    define USE_FAR_KEYWORD
+#    define FARDATA FAR
+#    include <dos.h>
+#  endif
+#endif
+
+/* SJT: default case */
+#ifndef FAR
+#  define FAR
+#endif
+
+/* At this point FAR is always defined */
+#ifndef FARDATA
+#  define FARDATA
+#endif
+
+/* Typedef for floating-point numbers that are converted
+   to fixed-point with a multiple of 100,000, e.g., int_gamma */
+typedef png_int_32 png_fixed_point;
+
+/* Add typedefs for pointers */
+typedef void            FAR * png_voidp;
+typedef png_byte        FAR * png_bytep;
+typedef png_uint_32     FAR * png_uint_32p;
+typedef png_int_32      FAR * png_int_32p;
+typedef png_uint_16     FAR * png_uint_16p;
+typedef png_int_16      FAR * png_int_16p;
+typedef PNG_CONST char  FAR * png_const_charp;
+typedef char            FAR * png_charp;
+typedef png_fixed_point FAR * png_fixed_point_p;
+
+#ifndef PNG_NO_STDIO
+typedef FILE                * png_FILE_p;
+#endif
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+typedef double          FAR * png_doublep;
+#endif
+
+/* Pointers to pointers; i.e. arrays */
+typedef png_byte        FAR * FAR * png_bytepp;
+typedef png_uint_32     FAR * FAR * png_uint_32pp;
+typedef png_int_32      FAR * FAR * png_int_32pp;
+typedef png_uint_16     FAR * FAR * png_uint_16pp;
+typedef png_int_16      FAR * FAR * png_int_16pp;
+typedef PNG_CONST char  FAR * FAR * png_const_charpp;
+typedef char            FAR * FAR * png_charpp;
+typedef png_fixed_point FAR * FAR * png_fixed_point_pp;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+typedef double          FAR * FAR * png_doublepp;
+#endif
+
+/* Pointers to pointers to pointers; i.e., pointer to array */
+typedef char            FAR * FAR * FAR * png_charppp;
+
+/* Define PNG_BUILD_DLL if the module being built is a Windows
+ * LIBPNG DLL.
+ *
+ * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL.
+ * It is equivalent to Microsoft predefined macro _DLL that is
+ * automatically defined when you compile using the share
+ * version of the CRT (C Run-Time library)
+ *
+ * The cygwin mods make this behavior a little different:
+ * Define PNG_BUILD_DLL if you are building a dll for use with cygwin
+ * Define PNG_STATIC if you are building a static library for use with cygwin,
+ *   -or- if you are building an application that you want to link to the
+ *   static library.
+ * PNG_USE_DLL is defined by default (no user action needed) unless one of
+ *   the other flags is defined.
+ */
+
+#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL))
+#  define PNG_DLL
+#endif
+
+#ifdef __CYGWIN__
+#  undef PNGAPI
+#  define PNGAPI __cdecl
+#  undef PNG_IMPEXP
+#  define PNG_IMPEXP
+#endif
+
+#define PNG_USE_LOCAL_ARRAYS /* Not used in libpng, defined for legacy apps */
+
+/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall",
+ * you may get warnings regarding the linkage of png_zalloc and png_zfree.
+ * Don't ignore those warnings; you must also reset the default calling
+ * convention in your compiler to match your PNGAPI, and you must build
+ * zlib and your applications the same way you build libpng.
+ */
+
+#if defined(__MINGW32__) && !defined(PNG_MODULEDEF)
+#  ifndef PNG_NO_MODULEDEF
+#    define PNG_NO_MODULEDEF
+#  endif
+#endif
+
+#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF)
+#  define PNG_IMPEXP
+#endif
+
+#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \
+    (( defined(_Windows) || defined(_WINDOWS) || \
+       defined(WIN32) || defined(_WIN32) || defined(__WIN32__) ))
+
+#  ifndef PNGAPI
+#     if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800))
+#        define PNGAPI __cdecl
+#     else
+#        define PNGAPI _cdecl
+#     endif
+#  endif
+
+#  if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \
+       0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */)
+#     define PNG_IMPEXP
+#  endif
+
+#  ifndef PNG_IMPEXP
+
+#    define PNG_EXPORT_TYPE1(type,symbol)  PNG_IMPEXP type PNGAPI symbol
+#    define PNG_EXPORT_TYPE2(type,symbol)  type PNG_IMPEXP PNGAPI symbol
+
+     /* Borland/Microsoft */
+#    if defined(_MSC_VER) || defined(__BORLANDC__)
+#      if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500)
+#         define PNG_EXPORT PNG_EXPORT_TYPE1
+#      else
+#         define PNG_EXPORT PNG_EXPORT_TYPE2
+#         ifdef PNG_BUILD_DLL
+#            define PNG_IMPEXP __export
+#         else
+#            define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in VC++ */
+#         endif                              /* Exists in Borland C++ for
+                                                C++ classes (== huge) */
+#      endif
+#    endif
+
+#    ifndef PNG_IMPEXP
+#      ifdef PNG_BUILD_DLL
+#        define PNG_IMPEXP __declspec(dllexport)
+#      else
+#        define PNG_IMPEXP __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* PNG_IMPEXP */
+#else /* !(DLL || non-cygwin WINDOWS) */
+#   if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
+#     ifndef PNGAPI
+#       define PNGAPI _System
+#     endif
+#   else
+#     if 0 /* ... other platforms, with other meanings */
+#     endif
+#   endif
+#endif
+
+#ifndef PNGAPI
+#  define PNGAPI
+#endif
+#ifndef PNG_IMPEXP
+#  define PNG_IMPEXP
+#endif
+
+#ifdef PNG_BUILDSYMS
+#  ifndef PNG_EXPORT
+#    define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END
+#  endif
+#endif
+
+#ifndef PNG_EXPORT
+#  define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol
+#endif
+
+/* Support for compiler specific function attributes.  These are used
+ * so that where compiler support is available incorrect use of API
+ * functions in png.h will generate compiler warnings.
+ *
+ * Added at libpng-1.2.41.
+ */
+
+#ifndef PNG_NO_PEDANTIC_WARNINGS
+#  ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED
+#    define PNG_PEDANTIC_WARNINGS_SUPPORTED
+#  endif
+#endif
+
+#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED
+/* Support for compiler specific function attributes.  These are used
+ * so that where compiler support is available incorrect use of API
+ * functions in png.h will generate compiler warnings.  Added at libpng
+ * version 1.2.41.
+ */
+#  ifdef __GNUC__
+#    ifndef PNG_USE_RESULT
+#      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
+#    endif
+#    ifndef PNG_NORETURN
+#      define PNG_NORETURN   __attribute__((__noreturn__))
+#    endif
+#    ifndef PNG_ALLOCATED
+#      define PNG_ALLOCATED  __attribute__((__malloc__))
+#    endif
+
+    /* This specifically protects structure members that should only be
+     * accessed from within the library, therefore should be empty during
+     * a library build.
+     */
+#    ifndef PNG_DEPRECATED
+#      define PNG_DEPRECATED __attribute__((__deprecated__))
+#    endif
+#    ifndef PNG_DEPSTRUCT
+#      define PNG_DEPSTRUCT  __attribute__((__deprecated__))
+#    endif
+#    ifndef PNG_PRIVATE
+#      if 0 /* Doesn't work so we use deprecated instead*/
+#        define PNG_PRIVATE \
+          __attribute__((warning("This function is not exported by libpng.")))
+#      else
+#        define PNG_PRIVATE \
+          __attribute__((__deprecated__))
+#      endif
+#    endif /* PNG_PRIVATE */
+#  endif /* __GNUC__ */
+#endif /* PNG_PEDANTIC_WARNINGS */
+
+#ifndef PNG_DEPRECATED
+#  define PNG_DEPRECATED  /* Use of this function is deprecated */
+#endif
+#ifndef PNG_USE_RESULT
+#  define PNG_USE_RESULT  /* The result of this function must be checked */
+#endif
+#ifndef PNG_NORETURN
+#  define PNG_NORETURN    /* This function does not return */
+#endif
+#ifndef PNG_ALLOCATED
+#  define PNG_ALLOCATED   /* The result of the function is new memory */
+#endif
+#ifndef PNG_DEPSTRUCT
+#  define PNG_DEPSTRUCT   /* Access to this struct member is deprecated */
+#endif
+#ifndef PNG_PRIVATE
+#  define PNG_PRIVATE     /* This is a private libpng function */
+#endif
+
+/* Users may want to use these so they are not private.  Any library
+ * functions that are passed far data must be model-independent.
+ */
+
+/* memory model/platform independent fns */
+#ifndef PNG_ABORT
+#  ifdef _WINDOWS_
+#     define PNG_ABORT() ExitProcess(0)
+#  else
+#     define PNG_ABORT() abort()
+#  endif
+#endif
+
+#ifdef USE_FAR_KEYWORD
+/* Use this to make far-to-near assignments */
+#  define CHECK   1
+#  define NOCHECK 0
+#  define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))
+#  define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))
+#  define png_strcpy  _fstrcpy
+#  define png_strncpy _fstrncpy   /* Added to v 1.2.6 */
+#  define png_strlen  _fstrlen
+#  define png_memcmp  _fmemcmp    /* SJT: added */
+#  define png_memcpy  _fmemcpy
+#  define png_memset  _fmemset
+#  define png_sprintf sprintf
+#else
+#  ifdef _WINDOWS_  /* Favor Windows over C runtime fns */
+#    define CVT_PTR(ptr)         (ptr)
+#    define CVT_PTR_NOCHECK(ptr) (ptr)
+#    define png_strcpy  lstrcpyA
+#    define png_strncpy lstrcpynA
+#    define png_strlen  lstrlenA
+#    define png_memcmp  memcmp
+#    define png_memcpy  CopyMemory
+#    define png_memset  memset
+#    define png_sprintf wsprintfA
+#  else
+#    define CVT_PTR(ptr)         (ptr)
+#    define CVT_PTR_NOCHECK(ptr) (ptr)
+#    define png_strcpy  strcpy
+#    define png_strncpy strncpy     /* Added to v 1.2.6 */
+#    define png_strlen  strlen
+#    define png_memcmp  memcmp      /* SJT: added */
+#    define png_memcpy  memcpy
+#    define png_memset  memset
+#    define png_sprintf sprintf
+#    ifndef PNG_NO_SNPRINTF
+#      ifdef _MSC_VER
+#        define png_snprintf _snprintf   /* Added to v 1.2.19 */
+#        define png_snprintf2 _snprintf
+#        define png_snprintf6 _snprintf
+#      else
+#        define png_snprintf snprintf   /* Added to v 1.2.19 */
+#        define png_snprintf2 snprintf
+#        define png_snprintf6 snprintf
+#      endif
+#    else
+       /* You don't have or don't want to use snprintf().  Caution: Using
+        * sprintf instead of snprintf exposes your application to accidental
+        * or malevolent buffer overflows.  If you don't have snprintf()
+        * as a general rule you should provide one (you can get one from
+        * Portable OpenSSH).
+        */
+#      define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1)
+#      define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2)
+#      define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \
+          sprintf(s1,fmt,x1,x2,x3,x4,x5,x6)
+#    endif
+#  endif
+#endif
+
+/* png_alloc_size_t is guaranteed to be no smaller than png_size_t,
+ * and no smaller than png_uint_32.  Casts from png_size_t or png_uint_32
+ * to png_alloc_size_t are not necessary; in fact, it is recommended
+ * not to use them at all so that the compiler can complain when something
+ * turns out to be problematic.
+ * Casts in the other direction (from png_alloc_size_t to png_size_t or
+ * png_uint_32) should be explicitly applied; however, we do not expect
+ * to encounter practical situations that require such conversions.
+ */
+#if defined(__TURBOC__) && !defined(__FLAT__)
+#  define  png_mem_alloc farmalloc
+#  define  png_mem_free  farfree
+   typedef unsigned long png_alloc_size_t;
+#else
+#  if defined(_MSC_VER) && defined(MAXSEG_64K)
+#    define  png_mem_alloc(s) halloc(s, 1)
+#    define  png_mem_free     hfree
+     typedef unsigned long    png_alloc_size_t;
+#  else
+#    if defined(_WINDOWS_) && (!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL)
+#      define  png_mem_alloc(s) HeapAlloc(GetProcessHeap(), 0, s)
+#      define  png_mem_free(p)  HeapFree(GetProcessHeap(), 0, p)
+       typedef DWORD            png_alloc_size_t;
+#    else
+#      define  png_mem_alloc malloc
+#      define  png_mem_free  free
+       typedef png_size_t    png_alloc_size_t;
+#    endif
+#  endif
+#endif
+/* End of memory model/platform independent support */
+
+/* Just a little check that someone hasn't tried to define something
+ * contradictory.
+ */
+#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)
+#  undef PNG_ZBUF_SIZE
+#  define PNG_ZBUF_SIZE 65536L
+#endif
+
+
+/* Added at libpng-1.2.8 */
+#endif /* PNG_VERSION_INFO_ONLY */
+
+#endif /* PNGCONF_H */
diff --git a/src/libpng/pngerror.c b/src/libpng/pngerror.c
index 725e0b673..633eae29f 100644
--- a/src/libpng/pngerror.c
+++ b/src/libpng/pngerror.c
@@ -1,386 +1,402 @@
-

-/* pngerror.c - stub functions for i/o and memory allocation

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This file provides a location for all error handling.  Users who

- * need special error handling are expected to write replacement functions

- * and use png_set_error_fn() to use those functions.  See the instructions

- * at each function.

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-

-static void /* PRIVATE */

-png_default_error PNGARG((png_structp png_ptr,

-  png_const_charp error_message)) PNG_NORETURN;

-#ifdef PNG_WARNINGS_SUPPORTED

-static void /* PRIVATE */

-png_default_warning PNGARG((png_structp png_ptr,

-  png_const_charp warning_message));

-#endif /* PNG_WARNINGS_SUPPORTED */

-

-/* This function is called whenever there is a fatal error.  This function

- * should not be changed.  If there is a need to handle errors differently,

- * you should supply a replacement error function and use png_set_error_fn()

- * to replace the error function at run-time.

- */

-#ifdef PNG_ERROR_TEXT_SUPPORTED

-void PNGAPI

-png_error(png_structp png_ptr, png_const_charp error_message)

-{

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-   char msg[16];

-   if (png_ptr != NULL)

-   {

-     if (png_ptr->flags&

-       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))

-     {

-       if (*error_message == PNG_LITERAL_SHARP)

-       {

-           /* Strip "#nnnn " from beginning of error message. */

-           int offset;

-           for (offset = 1; offset<15; offset++)

-              if (error_message[offset] == ' ')

-                  break;

-           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)

-           {

-              int i;

-              for (i = 0; i < offset - 1; i++)

-                 msg[i] = error_message[i + 1];

-              msg[i - 1] = '\0';

-              error_message = msg;

-           }

-           else

-              error_message += offset;

-       }

-       else

-       {

-           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)

-           {

-              msg[0] = '0';

-              msg[1] = '\0';

-              error_message = msg;

-           }

-       }

-     }

-   }

-#endif

-   if (png_ptr != NULL && png_ptr->error_fn != NULL)

-      (*(png_ptr->error_fn))(png_ptr, error_message);

-

-   /* If the custom handler doesn't exist, or if it returns,

-      use the default handler, which will not return. */

-   png_default_error(png_ptr, error_message);

-}

-#else

-void PNGAPI

-png_err(png_structp png_ptr)

-{

-   if (png_ptr != NULL && png_ptr->error_fn != NULL)

-      (*(png_ptr->error_fn))(png_ptr, '\0');

-

-   /* If the custom handler doesn't exist, or if it returns,

-      use the default handler, which will not return. */

-   png_default_error(png_ptr, '\0');

-}

-#endif /* PNG_ERROR_TEXT_SUPPORTED */

-

-#ifdef PNG_WARNINGS_SUPPORTED

-/* This function is called whenever there is a non-fatal error.  This function

- * should not be changed.  If there is a need to handle warnings differently,

- * you should supply a replacement warning function and use

- * png_set_error_fn() to replace the warning function at run-time.

- */

-void PNGAPI

-png_warning(png_structp png_ptr, png_const_charp warning_message)

-{

-   int offset = 0;

-   if (png_ptr != NULL)

-   {

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-   if (png_ptr->flags&

-     (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))

-#endif

-     {

-       if (*warning_message == PNG_LITERAL_SHARP)

-       {

-           for (offset = 1; offset < 15; offset++)

-              if (warning_message[offset] == ' ')

-                  break;

-       }

-     }

-   }

-   if (png_ptr != NULL && png_ptr->warning_fn != NULL)

-      (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);

-   else

-      png_default_warning(png_ptr, warning_message + offset);

-}

-#endif /* PNG_WARNINGS_SUPPORTED */

-

-#ifdef PNG_BENIGN_ERRORS_SUPPORTED

-void PNGAPI

-png_benign_error(png_structp png_ptr, png_const_charp error_message)

-{

-  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)

-    png_warning(png_ptr, error_message);

-  else

-    png_error(png_ptr, error_message);

-}

-#endif

-

-/* These utilities are used internally to build an error message that relates

- * to the current chunk.  The chunk name comes from png_ptr->chunk_name,

- * this is used to prefix the message.  The message is limited in length

- * to 63 bytes, the name characters are output as hex digits wrapped in []

- * if the character is invalid.

- */

-#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))

-static PNG_CONST char png_digit[16] = {

-   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

-   'A', 'B', 'C', 'D', 'E', 'F'

-};

-

-#define PNG_MAX_ERROR_TEXT 64

-#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)

-static void /* PRIVATE */

-png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp

-   error_message)

-{

-   int iout = 0, iin = 0;

-

-   while (iin < 4)

-   {

-      int c = png_ptr->chunk_name[iin++];

-      if (isnonalpha(c))

-      {

-         buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;

-         buffer[iout++] = png_digit[(c & 0xf0) >> 4];

-         buffer[iout++] = png_digit[c & 0x0f];

-         buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;

-      }

-      else

-      {

-         buffer[iout++] = (png_byte)c;

-      }

-   }

-

-   if (error_message == NULL)

-      buffer[iout] = '\0';

-   else

-   {

-      buffer[iout++] = ':';

-      buffer[iout++] = ' ';

-      png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);

-      buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';

-   }

-}

-

-#ifdef PNG_READ_SUPPORTED

-void PNGAPI

-png_chunk_error(png_structp png_ptr, png_const_charp error_message)

-{

-   char msg[18+PNG_MAX_ERROR_TEXT];

-   if (png_ptr == NULL)

-     png_error(png_ptr, error_message);

-   else

-   {

-     png_format_buffer(png_ptr, msg, error_message);

-     png_error(png_ptr, msg);

-   }

-}

-#endif /* PNG_READ_SUPPORTED */

-#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */

-

-#ifdef PNG_WARNINGS_SUPPORTED

-void PNGAPI

-png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)

-{

-   char msg[18+PNG_MAX_ERROR_TEXT];

-   if (png_ptr == NULL)

-     png_warning(png_ptr, warning_message);

-   else

-   {

-     png_format_buffer(png_ptr, msg, warning_message);

-     png_warning(png_ptr, msg);

-   }

-}

-#endif /* PNG_WARNINGS_SUPPORTED */

-

-#ifdef PNG_READ_SUPPORTED

-#ifdef PNG_BENIGN_ERRORS_SUPPORTED

-void PNGAPI

-png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)

-{

-  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)

-    png_chunk_warning(png_ptr, error_message);

-  else

-    png_chunk_error(png_ptr, error_message);

-}

-#endif

-#endif /* PNG_READ_SUPPORTED */

-

-/* This is the default error handling function.  Note that replacements for

- * this function MUST NOT RETURN, or the program will likely crash.  This

- * function is used by default, or if the program supplies NULL for the

- * error function pointer in png_set_error_fn().

- */

-static void /* PRIVATE */

-png_default_error(png_structp png_ptr, png_const_charp error_message)

-{

-#ifdef PNG_CONSOLE_IO_SUPPORTED

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-   if (*error_message == PNG_LITERAL_SHARP)

-   {

-     /* Strip "#nnnn " from beginning of error message. */

-     int offset;

-     char error_number[16];

-     for (offset = 0; offset<15; offset++)

-     {

-         error_number[offset] = error_message[offset + 1];

-         if (error_message[offset] == ' ')

-             break;

-     }

-     if ((offset > 1) && (offset < 15))

-     {

-       error_number[offset - 1] = '\0';

-       fprintf(stderr, "libpng error no. %s: %s",

-          error_number, error_message + offset + 1);

-       fprintf(stderr, PNG_STRING_NEWLINE);

-     }

-     else

-     {

-       fprintf(stderr, "libpng error: %s, offset=%d",

-          error_message, offset);

-       fprintf(stderr, PNG_STRING_NEWLINE);

-     }

-   }

-   else

-#endif

-   {

-      fprintf(stderr, "libpng error: %s", error_message);

-      fprintf(stderr, PNG_STRING_NEWLINE);

-   }

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-   if (png_ptr)

-   {

-#  ifdef USE_FAR_KEYWORD

-   {

-      jmp_buf jmpbuf;

-      png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));

-      longjmp(jmpbuf, 1);

-   }

-#  else

-   longjmp(png_ptr->jmpbuf, 1);

-#  endif

-   }

-#endif

-   /* Here if not setjmp support or if png_ptr is null. */

-   PNG_ABORT();

-#ifndef PNG_CONSOLE_IO_SUPPORTED

-   error_message = error_message; /* Make compiler happy */

-#endif

-}

-

-#ifdef PNG_WARNINGS_SUPPORTED

-/* This function is called when there is a warning, but the library thinks

- * it can continue anyway.  Replacement functions don't have to do anything

- * here if you don't want them to.  In the default configuration, png_ptr is

- * not used, but it is passed in case it may be useful.

- */

-static void /* PRIVATE */

-png_default_warning(png_structp png_ptr, png_const_charp warning_message)

-{

-#ifdef PNG_CONSOLE_IO_SUPPORTED

-#  ifdef PNG_ERROR_NUMBERS_SUPPORTED

-   if (*warning_message == PNG_LITERAL_SHARP)

-   {

-     int offset;

-     char warning_number[16];

-     for (offset = 0; offset < 15; offset++)

-     {

-        warning_number[offset] = warning_message[offset + 1];

-        if (warning_message[offset] == ' ')

-            break;

-     }

-     if ((offset > 1) && (offset < 15))

-     {

-       warning_number[offset + 1] = '\0';

-       fprintf(stderr, "libpng warning no. %s: %s",

-          warning_number, warning_message + offset);

-       fprintf(stderr, PNG_STRING_NEWLINE);

-     }

-     else

-     {

-       fprintf(stderr, "libpng warning: %s",

-          warning_message);

-       fprintf(stderr, PNG_STRING_NEWLINE);

-     }

-   }

-   else

-#  endif

-   {

-     fprintf(stderr, "libpng warning: %s", warning_message);

-     fprintf(stderr, PNG_STRING_NEWLINE);

-   }

-#else

-   warning_message = warning_message; /* Make compiler happy */

-#endif

-   png_ptr = png_ptr; /* Make compiler happy */

-}

-#endif /* PNG_WARNINGS_SUPPORTED */

-

-/* This function is called when the application wants to use another method

- * of handling errors and warnings.  Note that the error function MUST NOT

- * return to the calling routine or serious problems will occur.  The return

- * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)

- */

-void PNGAPI

-png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warning_fn)

-{

-   if (png_ptr == NULL)

-      return;

-   png_ptr->error_ptr = error_ptr;

-   png_ptr->error_fn = error_fn;

-   png_ptr->warning_fn = warning_fn;

-}

-

-

-/* This function returns a pointer to the error_ptr associated with the user

- * functions.  The application should free any memory associated with this

- * pointer before png_write_destroy and png_read_destroy are called.

- */

-png_voidp PNGAPI

-png_get_error_ptr(png_structp png_ptr)

-{

-   if (png_ptr == NULL)

-      return NULL;

-   return ((png_voidp)png_ptr->error_ptr);

-}

-

-

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-void PNGAPI

-png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)

-{

-   if (png_ptr != NULL)

-   {

-     png_ptr->flags &=

-       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);

-   }

-}

-#endif

-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

+
+/* pngerror.c - stub functions for i/o and memory allocation
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all error handling.  Users who
+ * need special error handling are expected to write replacement functions
+ * and use png_set_error_fn() to use those functions.  See the instructions
+ * at each function.
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#include "pngpriv.h"
+
+static void /* PRIVATE */
+png_default_error PNGARG((png_structp png_ptr,
+  png_const_charp error_message)) PNG_NORETURN;
+#ifdef PNG_WARNINGS_SUPPORTED
+static void /* PRIVATE */
+png_default_warning PNGARG((png_structp png_ptr,
+  png_const_charp warning_message));
+#endif /* PNG_WARNINGS_SUPPORTED */
+
+/* This function is called whenever there is a fatal error.  This function
+ * should not be changed.  If there is a need to handle errors differently,
+ * you should supply a replacement error function and use png_set_error_fn()
+ * to replace the error function at run-time.
+ */
+#ifdef PNG_ERROR_TEXT_SUPPORTED
+void PNGAPI
+png_error(png_structp png_ptr, png_const_charp error_message)
+{
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   char msg[16];
+   if (png_ptr != NULL)
+   {
+     if (png_ptr->flags&
+       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+     {
+       if (*error_message == PNG_LITERAL_SHARP)
+       {
+           /* Strip "#nnnn " from beginning of error message. */
+           int offset;
+           for (offset = 1; offset<15; offset++)
+              if (error_message[offset] == ' ')
+                  break;
+           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+           {
+              int i;
+              for (i = 0; i < offset - 1; i++)
+                 msg[i] = error_message[i + 1];
+              msg[i - 1] = '\0';
+              error_message = msg;
+           }
+           else
+              error_message += offset;
+       }
+       else
+       {
+           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+           {
+              msg[0] = '0';
+              msg[1] = '\0';
+              error_message = msg;
+           }
+       }
+     }
+   }
+#endif
+   if (png_ptr != NULL && png_ptr->error_fn != NULL)
+      (*(png_ptr->error_fn))(png_ptr, error_message);
+
+   /* If the custom handler doesn't exist, or if it returns,
+      use the default handler, which will not return. */
+   png_default_error(png_ptr, error_message);
+}
+#else
+void PNGAPI
+png_err(png_structp png_ptr)
+{
+   if (png_ptr != NULL && png_ptr->error_fn != NULL)
+      (*(png_ptr->error_fn))(png_ptr, '\0');
+
+   /* If the custom handler doesn't exist, or if it returns,
+      use the default handler, which will not return. */
+   png_default_error(png_ptr, '\0');
+}
+#endif /* PNG_ERROR_TEXT_SUPPORTED */
+
+#ifdef PNG_WARNINGS_SUPPORTED
+/* This function is called whenever there is a non-fatal error.  This function
+ * should not be changed.  If there is a need to handle warnings differently,
+ * you should supply a replacement warning function and use
+ * png_set_error_fn() to replace the warning function at run-time.
+ */
+void PNGAPI
+png_warning(png_structp png_ptr, png_const_charp warning_message)
+{
+   int offset = 0;
+   if (png_ptr != NULL)
+   {
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   if (png_ptr->flags&
+     (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+#endif
+     {
+       if (*warning_message == PNG_LITERAL_SHARP)
+       {
+           for (offset = 1; offset < 15; offset++)
+              if (warning_message[offset] == ' ')
+                  break;
+       }
+     }
+   }
+   if (png_ptr != NULL && png_ptr->warning_fn != NULL)
+      (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
+   else
+      png_default_warning(png_ptr, warning_message + offset);
+}
+#endif /* PNG_WARNINGS_SUPPORTED */
+
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+void PNGAPI
+png_benign_error(png_structp png_ptr, png_const_charp error_message)
+{
+  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
+    png_warning(png_ptr, error_message);
+  else
+    png_error(png_ptr, error_message);
+}
+#endif
+
+/* These utilities are used internally to build an error message that relates
+ * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
+ * this is used to prefix the message.  The message is limited in length
+ * to 63 bytes, the name characters are output as hex digits wrapped in []
+ * if the character is invalid.
+ */
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
+static PNG_CONST char png_digit[16] = {
+   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+   'A', 'B', 'C', 'D', 'E', 'F'
+};
+
+#define PNG_MAX_ERROR_TEXT 64
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
+static void /* PRIVATE */
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
+   error_message)
+{
+   int iout = 0, iin = 0;
+
+   while (iin < 4)
+   {
+      int c = png_ptr->chunk_name[iin++];
+      if (isnonalpha(c))
+      {
+         buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
+         buffer[iout++] = png_digit[(c & 0xf0) >> 4];
+         buffer[iout++] = png_digit[c & 0x0f];
+         buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
+      }
+      else
+      {
+         buffer[iout++] = (png_byte)c;
+      }
+   }
+
+   if (error_message == NULL)
+      buffer[iout] = '\0';
+   else
+   {
+      buffer[iout++] = ':';
+      buffer[iout++] = ' ';
+      png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);
+      buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';
+   }
+}
+
+#ifdef PNG_READ_SUPPORTED
+void PNGAPI
+png_chunk_error(png_structp png_ptr, png_const_charp error_message)
+{
+   char msg[18+PNG_MAX_ERROR_TEXT];
+   if (png_ptr == NULL)
+     png_error(png_ptr, error_message);
+   else
+   {
+     png_format_buffer(png_ptr, msg, error_message);
+     png_error(png_ptr, msg);
+   }
+}
+#endif /* PNG_READ_SUPPORTED */
+#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
+
+#ifdef PNG_WARNINGS_SUPPORTED
+void PNGAPI
+png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
+{
+   char msg[18+PNG_MAX_ERROR_TEXT];
+   if (png_ptr == NULL)
+     png_warning(png_ptr, warning_message);
+   else
+   {
+     png_format_buffer(png_ptr, msg, warning_message);
+     png_warning(png_ptr, msg);
+   }
+}
+#endif /* PNG_WARNINGS_SUPPORTED */
+
+#ifdef PNG_READ_SUPPORTED
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+void PNGAPI
+png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
+{
+  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
+    png_chunk_warning(png_ptr, error_message);
+  else
+    png_chunk_error(png_ptr, error_message);
+}
+#endif
+#endif /* PNG_READ_SUPPORTED */
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* This API only exists if ANSI-C style error handling is used,
+ * otherwise it is necessary for png_default_error to be overridden.
+ */
+jmp_buf* PNGAPI
+png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
+    size_t jmp_buf_size)
+{
+   if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
+      return NULL;
+
+   png_ptr->longjmp_fn = longjmp_fn;
+   return &png_ptr->jmpbuf;
+}
+#endif
+
+/* This is the default error handling function.  Note that replacements for
+ * this function MUST NOT RETURN, or the program will likely crash.  This
+ * function is used by default, or if the program supplies NULL for the
+ * error function pointer in png_set_error_fn().
+ */
+static void /* PRIVATE */
+png_default_error(png_structp png_ptr, png_const_charp error_message)
+{
+#ifdef PNG_CONSOLE_IO_SUPPORTED
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   if (*error_message == PNG_LITERAL_SHARP)
+   {
+     /* Strip "#nnnn " from beginning of error message. */
+     int offset;
+     char error_number[16];
+     for (offset = 0; offset<15; offset++)
+     {
+         error_number[offset] = error_message[offset + 1];
+         if (error_message[offset] == ' ')
+             break;
+     }
+     if ((offset > 1) && (offset < 15))
+     {
+       error_number[offset - 1] = '\0';
+       fprintf(stderr, "libpng error no. %s: %s",
+          error_number, error_message + offset + 1);
+       fprintf(stderr, PNG_STRING_NEWLINE);
+     }
+     else
+     {
+       fprintf(stderr, "libpng error: %s, offset=%d",
+          error_message, offset);
+       fprintf(stderr, PNG_STRING_NEWLINE);
+     }
+   }
+   else
+#endif
+   {
+      fprintf(stderr, "libpng error: %s", error_message);
+      fprintf(stderr, PNG_STRING_NEWLINE);
+   }
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+   if (png_ptr && png_ptr->longjmp_fn)
+   {
+#  ifdef USE_FAR_KEYWORD
+   {
+      jmp_buf jmpbuf;
+      png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+     png_ptr->longjmp_fn(jmpbuf, 1);
+   }
+#  else
+   png_ptr->longjmp_fn(png_ptr->jmpbuf, 1);
+#  endif
+   }
+#endif
+   /* Here if not setjmp support or if png_ptr is null. */
+   PNG_ABORT();
+#ifndef PNG_CONSOLE_IO_SUPPORTED
+   error_message = error_message; /* Make compiler happy */
+#endif
+}
+
+#ifdef PNG_WARNINGS_SUPPORTED
+/* This function is called when there is a warning, but the library thinks
+ * it can continue anyway.  Replacement functions don't have to do anything
+ * here if you don't want them to.  In the default configuration, png_ptr is
+ * not used, but it is passed in case it may be useful.
+ */
+static void /* PRIVATE */
+png_default_warning(png_structp png_ptr, png_const_charp warning_message)
+{
+#ifdef PNG_CONSOLE_IO_SUPPORTED
+#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   if (*warning_message == PNG_LITERAL_SHARP)
+   {
+     int offset;
+     char warning_number[16];
+     for (offset = 0; offset < 15; offset++)
+     {
+        warning_number[offset] = warning_message[offset + 1];
+        if (warning_message[offset] == ' ')
+            break;
+     }
+     if ((offset > 1) && (offset < 15))
+     {
+       warning_number[offset + 1] = '\0';
+       fprintf(stderr, "libpng warning no. %s: %s",
+          warning_number, warning_message + offset);
+       fprintf(stderr, PNG_STRING_NEWLINE);
+     }
+     else
+     {
+       fprintf(stderr, "libpng warning: %s",
+          warning_message);
+       fprintf(stderr, PNG_STRING_NEWLINE);
+     }
+   }
+   else
+#  endif
+   {
+     fprintf(stderr, "libpng warning: %s", warning_message);
+     fprintf(stderr, PNG_STRING_NEWLINE);
+   }
+#else
+   warning_message = warning_message; /* Make compiler happy */
+#endif
+   png_ptr = png_ptr; /* Make compiler happy */
+}
+#endif /* PNG_WARNINGS_SUPPORTED */
+
+/* This function is called when the application wants to use another method
+ * of handling errors and warnings.  Note that the error function MUST NOT
+ * return to the calling routine or serious problems will occur.  The return
+ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
+ */
+void PNGAPI
+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warning_fn)
+{
+   if (png_ptr == NULL)
+      return;
+   png_ptr->error_ptr = error_ptr;
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
+}
+
+
+/* This function returns a pointer to the error_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp PNGAPI
+png_get_error_ptr(png_structp png_ptr)
+{
+   if (png_ptr == NULL)
+      return NULL;
+   return ((png_voidp)png_ptr->error_ptr);
+}
+
+
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+void PNGAPI
+png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
+{
+   if (png_ptr != NULL)
+   {
+     png_ptr->flags &=
+       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
+   }
+}
+#endif
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pnggccrd.c b/src/libpng/pnggccrd.c
deleted file mode 100644
index 37f0950d6..000000000
--- a/src/libpng/pnggccrd.c
+++ /dev/null
@@ -1,103 +0,0 @@
-/* pnggccrd.c was removed from libpng-1.2.20. */

-

-/* This code snippet is for use by configure's compilation test. */

-

-#if (!defined _MSC_VER) && \

-    defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \

-    defined(PNG_MMX_CODE_SUPPORTED)

-

-int PNGAPI png_dummy_mmx_support(void);

-

-static int _mmx_supported = 2; // 0: no MMX; 1: MMX supported; 2: not tested

-

-int PNGAPI

-png_dummy_mmx_support(void) __attribute__((noinline));

-

-int PNGAPI

-png_dummy_mmx_support(void)

-{

-   int result;

-#ifdef PNG_MMX_CODE_SUPPORTED  // superfluous, but what the heck

-    __asm__ __volatile__ (

-#ifdef __x86_64__

-        "pushq %%rbx          \n\t"  // rbx gets clobbered by CPUID instruction

-        "pushq %%rcx          \n\t"  // so does rcx...

-        "pushq %%rdx          \n\t"  // ...and rdx (but rcx & rdx safe on Linux)

-        "pushfq               \n\t"  // save Eflag to stack

-        "popq %%rax           \n\t"  // get Eflag from stack into rax

-        "movq %%rax, %%rcx    \n\t"  // make another copy of Eflag in rcx

-        "xorl $0x200000, %%eax \n\t" // toggle ID bit in Eflag (i.e., bit 21)

-        "pushq %%rax          \n\t"  // save modified Eflag back to stack

-        "popfq                \n\t"  // restore modified value to Eflag reg

-        "pushfq               \n\t"  // save Eflag to stack

-        "popq %%rax           \n\t"  // get Eflag from stack

-        "pushq %%rcx          \n\t"  // save original Eflag to stack

-        "popfq                \n\t"  // restore original Eflag

-#else

-        "pushl %%ebx          \n\t"  // ebx gets clobbered by CPUID instruction

-        "pushl %%ecx          \n\t"  // so does ecx...

-        "pushl %%edx          \n\t"  // ...and edx (but ecx & edx safe on Linux)

-        "pushfl               \n\t"  // save Eflag to stack

-        "popl %%eax           \n\t"  // get Eflag from stack into eax

-        "movl %%eax, %%ecx    \n\t"  // make another copy of Eflag in ecx

-        "xorl $0x200000, %%eax \n\t" // toggle ID bit in Eflag (i.e., bit 21)

-        "pushl %%eax          \n\t"  // save modified Eflag back to stack

-        "popfl                \n\t"  // restore modified value to Eflag reg

-        "pushfl               \n\t"  // save Eflag to stack

-        "popl %%eax           \n\t"  // get Eflag from stack

-        "pushl %%ecx          \n\t"  // save original Eflag to stack

-        "popfl                \n\t"  // restore original Eflag

-#endif

-        "xorl %%ecx, %%eax    \n\t"  // compare new Eflag with original Eflag

-        "jz 0f                \n\t"  // if same, CPUID instr. is not supported

-

-        "xorl %%eax, %%eax    \n\t"  // set eax to zero

-//      ".byte  0x0f, 0xa2    \n\t"  // CPUID instruction (two-byte opcode)

-        "cpuid                \n\t"  // get the CPU identification info

-        "cmpl $1, %%eax       \n\t"  // make sure eax return non-zero value

-        "jl 0f                \n\t"  // if eax is zero, MMX is not supported

-

-        "xorl %%eax, %%eax    \n\t"  // set eax to zero and...

-        "incl %%eax           \n\t"  // ...increment eax to 1.  This pair is

-                                     // faster than the instruction "mov eax, 1"

-        "cpuid                \n\t"  // get the CPU identification info again

-        "andl $0x800000, %%edx \n\t" // mask out all bits but MMX bit (23)

-        "cmpl $0, %%edx       \n\t"  // 0 = MMX not supported

-        "jz 0f                \n\t"  // non-zero = yes, MMX IS supported

-

-        "movl $1, %%eax       \n\t"  // set return value to 1

-        "jmp  1f              \n\t"  // DONE:  have MMX support

-

-    "0:                       \n\t"  // .NOT_SUPPORTED: target label for jump instructions

-        "movl $0, %%eax       \n\t"  // set return value to 0

-    "1:                       \n\t"  // .RETURN: target label for jump instructions

-#ifdef __x86_64__

-        "popq %%rdx           \n\t"  // restore rdx

-        "popq %%rcx           \n\t"  // restore rcx

-        "popq %%rbx           \n\t"  // restore rbx

-#else

-        "popl %%edx           \n\t"  // restore edx

-        "popl %%ecx           \n\t"  // restore ecx

-        "popl %%ebx           \n\t"  // restore ebx

-#endif

-

-//      "ret                  \n\t"  // DONE:  no MMX support

-                                     // (fall through to standard C "ret")

-

-        : "=a" (result)              // output list

-

-        :                            // any variables used on input (none)

-

-                                     // no clobber list

-//      , "%ebx", "%ecx", "%edx"     // GRR:  we handle these manually

-//      , "memory"   // if write to a variable gcc thought was in a reg

-//      , "cc"       // "condition codes" (flag bits)

-    );

-    _mmx_supported = result;

-#else

-    _mmx_supported = 0;

-#endif /* PNG_MMX_CODE_SUPPORTED */

-

-    return _mmx_supported;

-}

-#endif

diff --git a/src/libpng/pngget.c b/src/libpng/pngget.c
index edb72adc9..8611b8585 100644
--- a/src/libpng/pngget.c
+++ b/src/libpng/pngget.c
@@ -1,945 +1,919 @@
-

-/* pngget.c - retrieval of values from info struct

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-

-png_uint_32 PNGAPI

-png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->valid & flag);

-

-   else

-      return(0);

-}

-

-png_uint_32 PNGAPI

-png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->rowbytes);

-

-   else

-      return(0);

-}

-

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-png_bytepp PNGAPI

-png_get_rows(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->row_pointers);

-

-   else

-      return(0);

-}

-#endif

-

-#ifdef PNG_EASY_ACCESS_SUPPORTED

-/* Easy access to info, added in libpng-0.99 */

-png_uint_32 PNGAPI

-png_get_image_width(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->width;

-

-   return (0);

-}

-

-png_uint_32 PNGAPI

-png_get_image_height(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->height;

-

-   return (0);

-}

-

-png_byte PNGAPI

-png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->bit_depth;

-

-   return (0);

-}

-

-png_byte PNGAPI

-png_get_color_type(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->color_type;

-

-   return (0);

-}

-

-png_byte PNGAPI

-png_get_filter_type(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->filter_type;

-

-   return (0);

-}

-

-png_byte PNGAPI

-png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->interlace_type;

-

-   return (0);

-}

-

-png_byte PNGAPI

-png_get_compression_type(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->compression_type;

-

-   return (0);

-}

-

-png_uint_32 PNGAPI

-png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-#ifdef PNG_pHYs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");

-

-      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)

-          return (0);

-

-      else

-          return (info_ptr->x_pixels_per_unit);

-   }

-#else

-   return (0);

-#endif

-   return (0);

-}

-

-png_uint_32 PNGAPI

-png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-#ifdef PNG_pHYs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");

-

-      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)

-          return (0);

-

-      else

-          return (info_ptr->y_pixels_per_unit);

-   }

-#else

-   return (0);

-#endif

-   return (0);

-}

-

-png_uint_32 PNGAPI

-png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-#ifdef PNG_pHYs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");

-

-      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||

-         info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)

-          return (0);

-

-      else

-          return (info_ptr->x_pixels_per_unit);

-   }

-#else

-   return (0);

-#endif

-   return (0);

-}

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-float PNGAPI

-png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)

-   {

-   if (png_ptr != NULL && info_ptr != NULL)

-#ifdef PNG_pHYs_SUPPORTED

-

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");

-

-      if (info_ptr->x_pixels_per_unit == 0)

-         return ((float)0.0);

-

-      else

-         return ((float)((float)info_ptr->y_pixels_per_unit

-            /(float)info_ptr->x_pixels_per_unit));

-   }

-#else

-      return (0.0);

-#endif

-   return ((float)0.0);

-}

-#endif

-

-png_int_32 PNGAPI

-png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-#ifdef PNG_oFFs_SUPPORTED

-

-   if (info_ptr->valid & PNG_INFO_oFFs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");

-

-      if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)

-          return (0);

-

-      else

-          return (info_ptr->x_offset);

-   }

-#else

-      return (0);

-#endif

-   return (0);

-}

-

-png_int_32 PNGAPI

-png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-

-#ifdef PNG_oFFs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_oFFs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");

-

-      if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)

-          return (0);

-

-      else

-          return (info_ptr->y_offset);

-   }

-#else

-   return (0);

-#endif

-   return (0);

-}

-

-png_int_32 PNGAPI

-png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-

-#ifdef PNG_oFFs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_oFFs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");

-

-      if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)

-          return (0);

-

-      else

-          return (info_ptr->x_offset);

-   }

-#else

-   return (0);

-#endif

-   return (0);

-}

-

-png_int_32 PNGAPI

-png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-

-#ifdef PNG_oFFs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_oFFs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");

-

-      if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)

-          return (0);

-

-      else

-          return (info_ptr->y_offset);

-   }

-#else

-   return (0);

-#endif

-   return (0);

-}

-

-#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)

-png_uint_32 PNGAPI

-png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

-{

-   return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)

-     *.0254 +.5));

-}

-

-png_uint_32 PNGAPI

-png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

-{

-   return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)

-     *.0254 +.5));

-}

-

-png_uint_32 PNGAPI

-png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

-{

-   return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)

-     *.0254 +.5));

-}

-

-float PNGAPI

-png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)

-{

-   return ((float)png_get_x_offset_microns(png_ptr, info_ptr)

-     *.00003937);

-}

-

-float PNGAPI

-png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)

-{

-   return ((float)png_get_y_offset_microns(png_ptr, info_ptr)

-     *.00003937);

-}

-

-#ifdef PNG_pHYs_SUPPORTED

-png_uint_32 PNGAPI

-png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

-{

-   png_uint_32 retval = 0;

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))

-   {

-      png_debug1(1, "in %s retrieval function", "pHYs");

-

-      if (res_x != NULL)

-      {

-         *res_x = info_ptr->x_pixels_per_unit;

-         retval |= PNG_INFO_pHYs;

-      }

-      if (res_y != NULL)

-      {

-         *res_y = info_ptr->y_pixels_per_unit;

-         retval |= PNG_INFO_pHYs;

-      }

-      if (unit_type != NULL)

-      {

-         *unit_type = (int)info_ptr->phys_unit_type;

-         retval |= PNG_INFO_pHYs;

-         if (*unit_type == 1)

-         {

-            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);

-            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);

-         }

-      }

-   }

-   return (retval);

-}

-#endif /* PNG_pHYs_SUPPORTED */

-#endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */

-

-/* png_get_channels really belongs in here, too, but it's been around longer */

-

-#endif  /* PNG_EASY_ACCESS_SUPPORTED */

-

-png_byte PNGAPI

-png_get_channels(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->channels);

-   else

-      return (0);

-}

-

-png_bytep PNGAPI

-png_get_signature(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->signature);

-   else

-      return (NULL);

-}

-

-#ifdef PNG_bKGD_SUPPORTED

-png_uint_32 PNGAPI

-png_get_bKGD(png_structp png_ptr, png_infop info_ptr,

-   png_color_16p *background)

-{

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)

-      && background != NULL)

-   {

-      png_debug1(1, "in %s retrieval function", "bKGD");

-

-      *background = &(info_ptr->background);

-      return (PNG_INFO_bKGD);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_cHRM_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_cHRM(png_structp png_ptr, png_infop info_ptr,

-   double *white_x, double *white_y, double *red_x, double *red_y,

-   double *green_x, double *green_y, double *blue_x, double *blue_y)

-{

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

-   {

-      png_debug1(1, "in %s retrieval function", "cHRM");

-

-      if (white_x != NULL)

-         *white_x = (double)info_ptr->x_white;

-      if (white_y != NULL)

-         *white_y = (double)info_ptr->y_white;

-      if (red_x != NULL)

-         *red_x = (double)info_ptr->x_red;

-      if (red_y != NULL)

-         *red_y = (double)info_ptr->y_red;

-      if (green_x != NULL)

-         *green_x = (double)info_ptr->x_green;

-      if (green_y != NULL)

-         *green_y = (double)info_ptr->y_green;

-      if (blue_x != NULL)

-         *blue_x = (double)info_ptr->x_blue;

-      if (blue_y != NULL)

-         *blue_y = (double)info_ptr->y_blue;

-      return (PNG_INFO_cHRM);

-   }

-   return (0);

-}

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,

-   png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,

-   png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,

-   png_fixed_point *blue_x, png_fixed_point *blue_y)

-{

-   png_debug1(1, "in %s retrieval function", "cHRM");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

-   {

-      if (white_x != NULL)

-         *white_x = info_ptr->int_x_white;

-      if (white_y != NULL)

-         *white_y = info_ptr->int_y_white;

-      if (red_x != NULL)

-         *red_x = info_ptr->int_x_red;

-      if (red_y != NULL)

-         *red_y = info_ptr->int_y_red;

-      if (green_x != NULL)

-         *green_x = info_ptr->int_x_green;

-      if (green_y != NULL)

-         *green_y = info_ptr->int_y_green;

-      if (blue_x != NULL)

-         *blue_x = info_ptr->int_x_blue;

-      if (blue_y != NULL)

-         *blue_y = info_ptr->int_y_blue;

-      return (PNG_INFO_cHRM);

-   }

-   return (0);

-}

-#endif

-#endif

-

-#ifdef PNG_gAMA_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)

-{

-   png_debug1(1, "in %s retrieval function", "gAMA");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

-      && file_gamma != NULL)

-   {

-      *file_gamma = (double)info_ptr->gamma;

-      return (PNG_INFO_gAMA);

-   }

-   return (0);

-}

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,

-    png_fixed_point *int_file_gamma)

-{

-   png_debug1(1, "in %s retrieval function", "gAMA");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

-      && int_file_gamma != NULL)

-   {

-      *int_file_gamma = info_ptr->int_gamma;

-      return (PNG_INFO_gAMA);

-   }

-   return (0);

-}

-#endif

-#endif

-

-#ifdef PNG_sRGB_SUPPORTED

-png_uint_32 PNGAPI

-png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)

-{

-   png_debug1(1, "in %s retrieval function", "sRGB");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)

-      && file_srgb_intent != NULL)

-   {

-      *file_srgb_intent = (int)info_ptr->srgb_intent;

-      return (PNG_INFO_sRGB);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_iCCP_SUPPORTED

-png_uint_32 PNGAPI

-png_get_iCCP(png_structp png_ptr, png_infop info_ptr,

-             png_charpp name, int *compression_type,

-             png_charpp profile, png_uint_32 *proflen)

-{

-   png_debug1(1, "in %s retrieval function", "iCCP");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)

-      && name != NULL && profile != NULL && proflen != NULL)

-   {

-      *name = info_ptr->iccp_name;

-      *profile = info_ptr->iccp_profile;

-      /* Compression_type is a dummy so the API won't have to change

-       * if we introduce multiple compression types later.

-       */

-      *proflen = (int)info_ptr->iccp_proflen;

-      *compression_type = (int)info_ptr->iccp_compression;

-      return (PNG_INFO_iCCP);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_sPLT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_sPLT(png_structp png_ptr, png_infop info_ptr,

-             png_sPLT_tpp spalettes)

-{

-   if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)

-   {

-     *spalettes = info_ptr->splt_palettes;

-     return ((png_uint_32)info_ptr->splt_palettes_num);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_hIST_SUPPORTED

-png_uint_32 PNGAPI

-png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)

-{

-   png_debug1(1, "in %s retrieval function", "hIST");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)

-      && hist != NULL)

-   {

-      *hist = info_ptr->hist;

-      return (PNG_INFO_hIST);

-   }

-   return (0);

-}

-#endif

-

-png_uint_32 PNGAPI

-png_get_IHDR(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 *width, png_uint_32 *height, int *bit_depth,

-   int *color_type, int *interlace_type, int *compression_type,

-   int *filter_type)

-

-{

-   png_debug1(1, "in %s retrieval function", "IHDR");

-

-   if (png_ptr == NULL || info_ptr == NULL || width == NULL ||

-       height == NULL || bit_depth == NULL || color_type == NULL)

-      return (0);

-

-   *width = info_ptr->width;

-   *height = info_ptr->height;

-   *bit_depth = info_ptr->bit_depth;

-   *color_type = info_ptr->color_type;

-

-   if (compression_type != NULL)

-      *compression_type = info_ptr->compression_type;

-

-   if (filter_type != NULL)

-      *filter_type = info_ptr->filter_type;

-

-   if (interlace_type != NULL)

-      *interlace_type = info_ptr->interlace_type;

-

-   /* This is redundant if we can be sure that the info_ptr values were all

-    * assigned in png_set_IHDR().  We do the check anyhow in case an

-    * application has ignored our advice not to mess with the members

-    * of info_ptr directly.

-    */

-   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,

-       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

-       info_ptr->compression_type, info_ptr->filter_type);

-

-   return (1);

-}

-

-#ifdef PNG_oFFs_SUPPORTED

-png_uint_32 PNGAPI

-png_get_oFFs(png_structp png_ptr, png_infop info_ptr,

-   png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)

-{

-   png_debug1(1, "in %s retrieval function", "oFFs");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)

-      && offset_x != NULL && offset_y != NULL && unit_type != NULL)

-   {

-      *offset_x = info_ptr->x_offset;

-      *offset_y = info_ptr->y_offset;

-      *unit_type = (int)info_ptr->offset_unit_type;

-      return (PNG_INFO_oFFs);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_pCAL_SUPPORTED

-png_uint_32 PNGAPI

-png_get_pCAL(png_structp png_ptr, png_infop info_ptr,

-   png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,

-   png_charp *units, png_charpp *params)

-{

-   png_debug1(1, "in %s retrieval function", "pCAL");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)

-       && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&

-       nparams != NULL && units != NULL && params != NULL)

-   {

-      *purpose = info_ptr->pcal_purpose;

-      *X0 = info_ptr->pcal_X0;

-      *X1 = info_ptr->pcal_X1;

-      *type = (int)info_ptr->pcal_type;

-      *nparams = (int)info_ptr->pcal_nparams;

-      *units = info_ptr->pcal_units;

-      *params = info_ptr->pcal_params;

-      return (PNG_INFO_pCAL);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_sCAL_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_sCAL(png_structp png_ptr, png_infop info_ptr,

-             int *unit, double *width, double *height)

-{

-    if (png_ptr != NULL && info_ptr != NULL &&

-        (info_ptr->valid & PNG_INFO_sCAL))

-    {

-        *unit = info_ptr->scal_unit;

-        *width = info_ptr->scal_pixel_width;

-        *height = info_ptr->scal_pixel_height;

-        return (PNG_INFO_sCAL);

-    }

-    return(0);

-}

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,

-             int *unit, png_charpp width, png_charpp height)

-{

-    if (png_ptr != NULL && info_ptr != NULL &&

-        (info_ptr->valid & PNG_INFO_sCAL))

-    {

-        *unit = info_ptr->scal_unit;

-        *width = info_ptr->scal_s_width;

-        *height = info_ptr->scal_s_height;

-        return (PNG_INFO_sCAL);

-    }

-    return(0);

-}

-#endif

-#endif

-#endif

-

-#ifdef PNG_pHYs_SUPPORTED

-png_uint_32 PNGAPI

-png_get_pHYs(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

-{

-   png_uint_32 retval = 0;

-

-   png_debug1(1, "in %s retrieval function", "pHYs");

-

-   if (png_ptr != NULL && info_ptr != NULL &&

-      (info_ptr->valid & PNG_INFO_pHYs))

-   {

-      if (res_x != NULL)

-      {

-         *res_x = info_ptr->x_pixels_per_unit;

-         retval |= PNG_INFO_pHYs;

-      }

-

-      if (res_y != NULL)

-      {

-         *res_y = info_ptr->y_pixels_per_unit;

-         retval |= PNG_INFO_pHYs;

-      }

-

-      if (unit_type != NULL)

-      {

-         *unit_type = (int)info_ptr->phys_unit_type;

-         retval |= PNG_INFO_pHYs;

-      }

-   }

-   return (retval);

-}

-#endif

-

-png_uint_32 PNGAPI

-png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,

-   int *num_palette)

-{

-   png_debug1(1, "in %s retrieval function", "PLTE");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)

-       && palette != NULL)

-   {

-      *palette = info_ptr->palette;

-      *num_palette = info_ptr->num_palette;

-      png_debug1(3, "num_palette = %d", *num_palette);

-      return (PNG_INFO_PLTE);

-   }

-   return (0);

-}

-

-#ifdef PNG_sBIT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)

-{

-   png_debug1(1, "in %s retrieval function", "sBIT");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)

-      && sig_bit != NULL)

-   {

-      *sig_bit = &(info_ptr->sig_bit);

-      return (PNG_INFO_sBIT);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_TEXT_SUPPORTED

-png_uint_32 PNGAPI

-png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,

-   int *num_text)

-{

-   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)

-   {

-      png_debug1(1, "in %s retrieval function",

-         (png_ptr->chunk_name[0] == '\0' ? "text"

-             : (png_const_charp)png_ptr->chunk_name));

-

-      if (text_ptr != NULL)

-         *text_ptr = info_ptr->text;

-

-      if (num_text != NULL)

-         *num_text = info_ptr->num_text;

-

-      return ((png_uint_32)info_ptr->num_text);

-   }

-   if (num_text != NULL)

-     *num_text = 0;

-   return(0);

-}

-#endif

-

-#ifdef PNG_tIME_SUPPORTED

-png_uint_32 PNGAPI

-png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)

-{

-   png_debug1(1, "in %s retrieval function", "tIME");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)

-       && mod_time != NULL)

-   {

-      *mod_time = &(info_ptr->mod_time);

-      return (PNG_INFO_tIME);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_tRNS_SUPPORTED

-png_uint_32 PNGAPI

-png_get_tRNS(png_structp png_ptr, png_infop info_ptr,

-   png_bytep *trans, int *num_trans, png_color_16p *trans_values)

-{

-   png_uint_32 retval = 0;

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

-   {

-      png_debug1(1, "in %s retrieval function", "tRNS");

-

-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-          if (trans != NULL)

-          {

-             *trans = info_ptr->trans;

-             retval |= PNG_INFO_tRNS;

-          }

-

-          if (trans_values != NULL)

-             *trans_values = &(info_ptr->trans_values);

-      }

-      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */

-      {

-          if (trans_values != NULL)

-          {

-             *trans_values = &(info_ptr->trans_values);

-             retval |= PNG_INFO_tRNS;

-          }

-

-          if (trans != NULL)

-             *trans = NULL;

-      }

-      if (num_trans != NULL)

-      {

-         *num_trans = info_ptr->num_trans;

-         retval |= PNG_INFO_tRNS;

-      }

-   }

-   return (retval);

-}

-#endif

-

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-png_uint_32 PNGAPI

-png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,

-             png_unknown_chunkpp unknowns)

-{

-   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)

-   {

-     *unknowns = info_ptr->unknown_chunks;

-     return ((png_uint_32)info_ptr->unknown_chunks_num);

-   }

-   return (0);

-}

-#endif

-

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-png_byte PNGAPI

-png_get_rgb_to_gray_status (png_structp png_ptr)

-{

-   return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);

-}

-#endif

-

-#ifdef PNG_USER_CHUNKS_SUPPORTED

-png_voidp PNGAPI

-png_get_user_chunk_ptr(png_structp png_ptr)

-{

-   return (png_ptr? png_ptr->user_chunk_ptr : NULL);

-}

-#endif

-

-#ifdef PNG_WRITE_SUPPORTED

-png_uint_32 PNGAPI

-png_get_compression_buffer_size(png_structp png_ptr)

-{

-   return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);

-}

-#endif

-

-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

-#ifndef PNG_1_0_X

-/* This function was added to libpng 1.2.0 and should exist by default */

-png_uint_32 PNGAPI

-png_get_asm_flags (png_structp png_ptr)

-{

-    /* Obsolete, to be removed from libpng-1.4.0 */

-    return (png_ptr? 0L: 0L);

-}

-

-/* This function was added to libpng 1.2.0 and should exist by default */

-png_uint_32 PNGAPI

-png_get_asm_flagmask (int flag_select)

-{

-    /* Obsolete, to be removed from libpng-1.4.0 */

-    flag_select=flag_select;

-    return 0L;

-}

-

-    /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */

-/* This function was added to libpng 1.2.0 */

-png_uint_32 PNGAPI

-png_get_mmx_flagmask (int flag_select, int *compilerID)

-{

-    /* Obsolete, to be removed from libpng-1.4.0 */

-    flag_select=flag_select;

-    *compilerID = -1;   /* unknown (i.e., no asm/MMX code compiled) */

-    return 0L;

-}

-

-/* This function was added to libpng 1.2.0 */

-png_byte PNGAPI

-png_get_mmx_bitdepth_threshold (png_structp png_ptr)

-{

-    /* Obsolete, to be removed from libpng-1.4.0 */

-    return (png_ptr? 0: 0);

-}

-

-/* This function was added to libpng 1.2.0 */

-png_uint_32 PNGAPI

-png_get_mmx_rowbytes_threshold (png_structp png_ptr)

-{

-    /* Obsolete, to be removed from libpng-1.4.0 */

-    return (png_ptr? 0L: 0L);

-}

-#endif /* ?PNG_1_0_X */

-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */

-

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-/* These functions were added to libpng 1.2.6 */

-png_uint_32 PNGAPI

-png_get_user_width_max (png_structp png_ptr)

-{

-    return (png_ptr? png_ptr->user_width_max : 0);

-}

-png_uint_32 PNGAPI

-png_get_user_height_max (png_structp png_ptr)

-{

-    return (png_ptr? png_ptr->user_height_max : 0);

-}

-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */

-

-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

+
+/* pngget.c - retrieval of values from info struct
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#include "pngpriv.h"
+
+png_uint_32 PNGAPI
+png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->valid & flag);
+
+   else
+      return(0);
+}
+
+png_size_t PNGAPI
+png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->rowbytes);
+
+   else
+      return(0);
+}
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+png_bytepp PNGAPI
+png_get_rows(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->row_pointers);
+
+   else
+      return(0);
+}
+#endif
+
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* Easy access to info, added in libpng-0.99 */
+png_uint_32 PNGAPI
+png_get_image_width(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return info_ptr->width;
+
+   return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_image_height(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return info_ptr->height;
+
+   return (0);
+}
+
+png_byte PNGAPI
+png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return info_ptr->bit_depth;
+
+   return (0);
+}
+
+png_byte PNGAPI
+png_get_color_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return info_ptr->color_type;
+
+   return (0);
+}
+
+png_byte PNGAPI
+png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return info_ptr->filter_type;
+
+   return (0);
+}
+
+png_byte PNGAPI
+png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return info_ptr->interlace_type;
+
+   return (0);
+}
+
+png_byte PNGAPI
+png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return info_ptr->compression_type;
+
+   return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+#ifdef PNG_pHYs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_pHYs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");
+
+      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+          return (0);
+
+      else
+          return (info_ptr->x_pixels_per_unit);
+   }
+#else
+   return (0);
+#endif
+   return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+#ifdef PNG_pHYs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_pHYs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");
+
+      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
+          return (0);
+
+      else
+          return (info_ptr->y_pixels_per_unit);
+   }
+#else
+   return (0);
+#endif
+   return (0);
+}
+
+png_uint_32 PNGAPI
+png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+#ifdef PNG_pHYs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_pHYs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
+
+      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
+         info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
+          return (0);
+
+      else
+          return (info_ptr->x_pixels_per_unit);
+   }
+#else
+   return (0);
+#endif
+   return (0);
+}
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+float PNGAPI
+png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
+   {
+   if (png_ptr != NULL && info_ptr != NULL)
+#ifdef PNG_pHYs_SUPPORTED
+
+   if (info_ptr->valid & PNG_INFO_pHYs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
+
+      if (info_ptr->x_pixels_per_unit == 0)
+         return ((float)0.0);
+
+      else
+         return ((float)((float)info_ptr->y_pixels_per_unit
+            /(float)info_ptr->x_pixels_per_unit));
+   }
+#else
+      return (0.0);
+#endif
+   return ((float)0.0);
+}
+#endif
+
+png_int_32 PNGAPI
+png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+#ifdef PNG_oFFs_SUPPORTED
+
+   if (info_ptr->valid & PNG_INFO_oFFs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
+
+      if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+          return (0);
+
+      else
+          return (info_ptr->x_offset);
+   }
+#else
+      return (0);
+#endif
+   return (0);
+}
+
+png_int_32 PNGAPI
+png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+
+#ifdef PNG_oFFs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_oFFs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
+
+      if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
+          return (0);
+
+      else
+          return (info_ptr->y_offset);
+   }
+#else
+   return (0);
+#endif
+   return (0);
+}
+
+png_int_32 PNGAPI
+png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+
+#ifdef PNG_oFFs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_oFFs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
+
+      if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+          return (0);
+
+      else
+          return (info_ptr->x_offset);
+   }
+#else
+   return (0);
+#endif
+   return (0);
+}
+
+png_int_32 PNGAPI
+png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+
+#ifdef PNG_oFFs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_oFFs)
+   {
+      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
+
+      if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
+          return (0);
+
+      else
+          return (info_ptr->y_offset);
+   }
+#else
+   return (0);
+#endif
+   return (0);
+}
+
+#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
+png_uint_32 PNGAPI
+png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
+     *.0254 +.5));
+}
+
+png_uint_32 PNGAPI
+png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
+     *.0254 +.5));
+}
+
+png_uint_32 PNGAPI
+png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
+     *.0254 +.5));
+}
+
+float PNGAPI
+png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
+     *.00003937);
+}
+
+float PNGAPI
+png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
+{
+   return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
+     *.00003937);
+}
+
+#ifdef PNG_pHYs_SUPPORTED
+png_uint_32 PNGAPI
+png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+{
+   png_uint_32 retval = 0;
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_debug1(1, "in %s retrieval function", "pHYs");
+
+      if (res_x != NULL)
+      {
+         *res_x = info_ptr->x_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (res_y != NULL)
+      {
+         *res_y = info_ptr->y_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+      if (unit_type != NULL)
+      {
+         *unit_type = (int)info_ptr->phys_unit_type;
+         retval |= PNG_INFO_pHYs;
+         if (*unit_type == 1)
+         {
+            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
+            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
+         }
+      }
+   }
+   return (retval);
+}
+#endif /* PNG_pHYs_SUPPORTED */
+#endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
+
+/* png_get_channels really belongs in here, too, but it's been around longer */
+
+#endif  /* PNG_EASY_ACCESS_SUPPORTED */
+
+png_byte PNGAPI
+png_get_channels(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->channels);
+   else
+      return (0);
+}
+
+png_bytep PNGAPI
+png_get_signature(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return(info_ptr->signature);
+   else
+      return (NULL);
+}
+
+#ifdef PNG_bKGD_SUPPORTED
+png_uint_32 PNGAPI
+png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
+   png_color_16p *background)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
+      && background != NULL)
+   {
+      png_debug1(1, "in %s retrieval function", "bKGD");
+
+      *background = &(info_ptr->background);
+      return (PNG_INFO_bKGD);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
+   double *white_x, double *white_y, double *red_x, double *red_y,
+   double *green_x, double *green_y, double *blue_x, double *blue_y)
+{
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+   {
+      png_debug1(1, "in %s retrieval function", "cHRM");
+
+      if (white_x != NULL)
+         *white_x = (double)info_ptr->x_white;
+      if (white_y != NULL)
+         *white_y = (double)info_ptr->y_white;
+      if (red_x != NULL)
+         *red_x = (double)info_ptr->x_red;
+      if (red_y != NULL)
+         *red_y = (double)info_ptr->y_red;
+      if (green_x != NULL)
+         *green_x = (double)info_ptr->x_green;
+      if (green_y != NULL)
+         *green_y = (double)info_ptr->y_green;
+      if (blue_x != NULL)
+         *blue_x = (double)info_ptr->x_blue;
+      if (blue_y != NULL)
+         *blue_y = (double)info_ptr->y_blue;
+      return (PNG_INFO_cHRM);
+   }
+   return (0);
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
+   png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
+   png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
+   png_fixed_point *blue_x, png_fixed_point *blue_y)
+{
+   png_debug1(1, "in %s retrieval function", "cHRM");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+   {
+      if (white_x != NULL)
+         *white_x = info_ptr->int_x_white;
+      if (white_y != NULL)
+         *white_y = info_ptr->int_y_white;
+      if (red_x != NULL)
+         *red_x = info_ptr->int_x_red;
+      if (red_y != NULL)
+         *red_y = info_ptr->int_y_red;
+      if (green_x != NULL)
+         *green_x = info_ptr->int_x_green;
+      if (green_y != NULL)
+         *green_y = info_ptr->int_y_green;
+      if (blue_x != NULL)
+         *blue_x = info_ptr->int_x_blue;
+      if (blue_y != NULL)
+         *blue_y = info_ptr->int_y_blue;
+      return (PNG_INFO_cHRM);
+   }
+   return (0);
+}
+#endif
+#endif
+
+#ifdef PNG_gAMA_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
+{
+   png_debug1(1, "in %s retrieval function", "gAMA");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+      && file_gamma != NULL)
+   {
+      *file_gamma = (double)info_ptr->gamma;
+      return (PNG_INFO_gAMA);
+   }
+   return (0);
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
+    png_fixed_point *int_file_gamma)
+{
+   png_debug1(1, "in %s retrieval function", "gAMA");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+      && int_file_gamma != NULL)
+   {
+      *int_file_gamma = info_ptr->int_gamma;
+      return (PNG_INFO_gAMA);
+   }
+   return (0);
+}
+#endif
+#endif
+
+#ifdef PNG_sRGB_SUPPORTED
+png_uint_32 PNGAPI
+png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
+{
+   png_debug1(1, "in %s retrieval function", "sRGB");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
+      && file_srgb_intent != NULL)
+   {
+      *file_srgb_intent = (int)info_ptr->srgb_intent;
+      return (PNG_INFO_sRGB);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+png_uint_32 PNGAPI
+png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
+             png_charpp name, int *compression_type,
+             png_charpp profile, png_uint_32 *proflen)
+{
+   png_debug1(1, "in %s retrieval function", "iCCP");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
+      && name != NULL && profile != NULL && proflen != NULL)
+   {
+      *name = info_ptr->iccp_name;
+      *profile = info_ptr->iccp_profile;
+      /* Compression_type is a dummy so the API won't have to change
+       * if we introduce multiple compression types later.
+       */
+      *proflen = (int)info_ptr->iccp_proflen;
+      *compression_type = (int)info_ptr->iccp_compression;
+      return (PNG_INFO_iCCP);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
+             png_sPLT_tpp spalettes)
+{
+   if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
+   {
+     *spalettes = info_ptr->splt_palettes;
+     return ((png_uint_32)info_ptr->splt_palettes_num);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+png_uint_32 PNGAPI
+png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
+{
+   png_debug1(1, "in %s retrieval function", "hIST");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
+      && hist != NULL)
+   {
+      *hist = info_ptr->hist;
+      return (PNG_INFO_hIST);
+   }
+   return (0);
+}
+#endif
+
+png_uint_32 PNGAPI
+png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *width, png_uint_32 *height, int *bit_depth,
+   int *color_type, int *interlace_type, int *compression_type,
+   int *filter_type)
+
+{
+   png_debug1(1, "in %s retrieval function", "IHDR");
+
+   if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
+       height == NULL || bit_depth == NULL || color_type == NULL)
+      return (0);
+
+   *width = info_ptr->width;
+   *height = info_ptr->height;
+   *bit_depth = info_ptr->bit_depth;
+   *color_type = info_ptr->color_type;
+
+   if (compression_type != NULL)
+      *compression_type = info_ptr->compression_type;
+
+   if (filter_type != NULL)
+      *filter_type = info_ptr->filter_type;
+
+   if (interlace_type != NULL)
+      *interlace_type = info_ptr->interlace_type;
+
+   /* This is redundant if we can be sure that the info_ptr values were all
+    * assigned in png_set_IHDR().  We do the check anyhow in case an
+    * application has ignored our advice not to mess with the members
+    * of info_ptr directly.
+    */
+   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
+       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
+       info_ptr->compression_type, info_ptr->filter_type);
+
+   return (1);
+}
+
+#ifdef PNG_oFFs_SUPPORTED
+png_uint_32 PNGAPI
+png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
+   png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
+{
+   png_debug1(1, "in %s retrieval function", "oFFs");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
+      && offset_x != NULL && offset_y != NULL && unit_type != NULL)
+   {
+      *offset_x = info_ptr->x_offset;
+      *offset_y = info_ptr->y_offset;
+      *unit_type = (int)info_ptr->offset_unit_type;
+      return (PNG_INFO_oFFs);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+png_uint_32 PNGAPI
+png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
+   png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
+   png_charp *units, png_charpp *params)
+{
+   png_debug1(1, "in %s retrieval function", "pCAL");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
+       && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
+       nparams != NULL && units != NULL && params != NULL)
+   {
+      *purpose = info_ptr->pcal_purpose;
+      *X0 = info_ptr->pcal_X0;
+      *X1 = info_ptr->pcal_X1;
+      *type = (int)info_ptr->pcal_type;
+      *nparams = (int)info_ptr->pcal_nparams;
+      *units = info_ptr->pcal_units;
+      *params = info_ptr->pcal_params;
+      return (PNG_INFO_pCAL);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_sCAL_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
+             int *unit, double *width, double *height)
+{
+    if (png_ptr != NULL && info_ptr != NULL &&
+        (info_ptr->valid & PNG_INFO_sCAL))
+    {
+        *unit = info_ptr->scal_unit;
+        *width = info_ptr->scal_pixel_width;
+        *height = info_ptr->scal_pixel_height;
+        return (PNG_INFO_sCAL);
+    }
+    return(0);
+}
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
+             int *unit, png_charpp width, png_charpp height)
+{
+    if (png_ptr != NULL && info_ptr != NULL &&
+        (info_ptr->valid & PNG_INFO_sCAL))
+    {
+        *unit = info_ptr->scal_unit;
+        *width = info_ptr->scal_s_width;
+        *height = info_ptr->scal_s_height;
+        return (PNG_INFO_sCAL);
+    }
+    return(0);
+}
+#endif
+#endif
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+png_uint_32 PNGAPI
+png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+{
+   png_uint_32 retval = 0;
+
+   png_debug1(1, "in %s retrieval function", "pHYs");
+
+   if (png_ptr != NULL && info_ptr != NULL &&
+      (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      if (res_x != NULL)
+      {
+         *res_x = info_ptr->x_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+
+      if (res_y != NULL)
+      {
+         *res_y = info_ptr->y_pixels_per_unit;
+         retval |= PNG_INFO_pHYs;
+      }
+
+      if (unit_type != NULL)
+      {
+         *unit_type = (int)info_ptr->phys_unit_type;
+         retval |= PNG_INFO_pHYs;
+      }
+   }
+   return (retval);
+}
+#endif
+
+png_uint_32 PNGAPI
+png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
+   int *num_palette)
+{
+   png_debug1(1, "in %s retrieval function", "PLTE");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
+       && palette != NULL)
+   {
+      *palette = info_ptr->palette;
+      *num_palette = info_ptr->num_palette;
+      png_debug1(3, "num_palette = %d", *num_palette);
+      return (PNG_INFO_PLTE);
+   }
+   return (0);
+}
+
+#ifdef PNG_sBIT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
+{
+   png_debug1(1, "in %s retrieval function", "sBIT");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
+      && sig_bit != NULL)
+   {
+      *sig_bit = &(info_ptr->sig_bit);
+      return (PNG_INFO_sBIT);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_TEXT_SUPPORTED
+png_uint_32 PNGAPI
+png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
+   int *num_text)
+{
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
+   {
+      png_debug1(1, "in %s retrieval function",
+         (png_ptr->chunk_name[0] == '\0' ? "text"
+             : (png_const_charp)png_ptr->chunk_name));
+
+      if (text_ptr != NULL)
+         *text_ptr = info_ptr->text;
+
+      if (num_text != NULL)
+         *num_text = info_ptr->num_text;
+
+      return ((png_uint_32)info_ptr->num_text);
+   }
+   if (num_text != NULL)
+     *num_text = 0;
+   return(0);
+}
+#endif
+
+#ifdef PNG_tIME_SUPPORTED
+png_uint_32 PNGAPI
+png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
+{
+   png_debug1(1, "in %s retrieval function", "tIME");
+
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
+       && mod_time != NULL)
+   {
+      *mod_time = &(info_ptr->mod_time);
+      return (PNG_INFO_tIME);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+png_uint_32 PNGAPI
+png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
+   png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
+{
+   png_uint_32 retval = 0;
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
+   {
+      png_debug1(1, "in %s retrieval function", "tRNS");
+
+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+          if (trans_alpha != NULL)
+          {
+             *trans_alpha = info_ptr->trans_alpha;
+             retval |= PNG_INFO_tRNS;
+          }
+
+          if (trans_color != NULL)
+             *trans_color = &(info_ptr->trans_color);
+      }
+      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
+      {
+          if (trans_color != NULL)
+          {
+             *trans_color = &(info_ptr->trans_color);
+             retval |= PNG_INFO_tRNS;
+          }
+
+          if (trans_alpha != NULL)
+             *trans_alpha = NULL;
+      }
+      if (num_trans != NULL)
+      {
+         *num_trans = info_ptr->num_trans;
+         retval |= PNG_INFO_tRNS;
+      }
+   }
+   return (retval);
+}
+#endif
+
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+png_uint_32 PNGAPI
+png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
+             png_unknown_chunkpp unknowns)
+{
+   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
+   {
+     *unknowns = info_ptr->unknown_chunks;
+     return ((png_uint_32)info_ptr->unknown_chunks_num);
+   }
+   return (0);
+}
+#endif
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+png_byte PNGAPI
+png_get_rgb_to_gray_status (png_structp png_ptr)
+{
+   return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);
+}
+#endif
+
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+png_voidp PNGAPI
+png_get_user_chunk_ptr(png_structp png_ptr)
+{
+   return (png_ptr? png_ptr->user_chunk_ptr : NULL);
+}
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+png_size_t PNGAPI
+png_get_compression_buffer_size(png_structp png_ptr)
+{
+   return (png_ptr ? png_ptr->zbuf_size : 0L);
+}
+#endif
+
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+/* These functions were added to libpng 1.2.6 */
+png_uint_32 PNGAPI
+png_get_user_width_max (png_structp png_ptr)
+{
+    return (png_ptr? png_ptr->user_width_max : 0);
+}
+png_uint_32 PNGAPI
+png_get_user_height_max (png_structp png_ptr)
+{
+    return (png_ptr? png_ptr->user_height_max : 0);
+}
+/* This function was added to libpng 1.4.0 */
+png_uint_32 PNGAPI
+png_get_chunk_cache_max (png_structp png_ptr)
+{
+    return (png_ptr? png_ptr->user_chunk_cache_max? 0x7fffffffL :
+       png_ptr->user_chunk_cache_max - 1 : 0);
+}
+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
+
+#ifdef PNG_IO_STATE_SUPPORTED
+png_uint_32 PNGAPI
+png_get_io_state (png_structp png_ptr)
+{
+    return png_ptr->io_state;
+}
+
+png_bytep PNGAPI
+png_get_io_chunk_name (png_structp png_ptr)
+{
+   return png_ptr->chunk_name;
+}
+#endif /* ?PNG_IO_STATE_SUPPORTED */
+
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pngmem.c b/src/libpng/pngmem.c
index b7f659883..dee296656 100644
--- a/src/libpng/pngmem.c
+++ b/src/libpng/pngmem.c
@@ -1,641 +1,611 @@
-

-/* pngmem.c - stub functions for memory allocation

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This file provides a location for all memory allocation.  Users who

- * need special memory handling are expected to supply replacement

- * functions for png_malloc() and png_free(), and to use

- * png_create_read_struct_2() and png_create_write_struct_2() to

- * identify the replacement functions.

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-

-/* Borland DOS special memory handler */

-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)

-/* If you change this, be sure to change the one in png.h also */

-

-/* Allocate memory for a png_struct.  The malloc and memset can be replaced

-   by a single call to calloc() if this is thought to improve performance. */

-png_voidp /* PRIVATE */

-png_create_struct(int type)

-{

-#ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));

-}

-

-/* Alternate version of png_create_struct, for use with user-defined malloc. */

-png_voidp /* PRIVATE */

-png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)

-{

-#endif /* PNG_USER_MEM_SUPPORTED */

-   png_size_t size;

-   png_voidp struct_ptr;

-

-   if (type == PNG_STRUCT_INFO)

-      size = png_sizeof(png_info);

-   else if (type == PNG_STRUCT_PNG)

-      size = png_sizeof(png_struct);

-   else

-      return (png_get_copyright(NULL));

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   if (malloc_fn != NULL)

-   {

-      png_struct dummy_struct;

-      png_structp png_ptr = &dummy_struct;

-      png_ptr->mem_ptr=mem_ptr;

-      struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);

-   }

-   else

-#endif /* PNG_USER_MEM_SUPPORTED */

-   struct_ptr = (png_voidp)farmalloc(size);

-   if (struct_ptr != NULL)

-      png_memset(struct_ptr, 0, size);

-   return (struct_ptr);

-}

-

-/* Free memory allocated by a png_create_struct() call */

-void /* PRIVATE */

-png_destroy_struct(png_voidp struct_ptr)

-{

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);

-}

-

-/* Free memory allocated by a png_create_struct() call */

-void /* PRIVATE */

-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,

-    png_voidp mem_ptr)

-{

-#endif

-   if (struct_ptr != NULL)

-   {

-#ifdef PNG_USER_MEM_SUPPORTED

-      if (free_fn != NULL)

-      {

-         png_struct dummy_struct;

-         png_structp png_ptr = &dummy_struct;

-         png_ptr->mem_ptr=mem_ptr;

-         (*(free_fn))(png_ptr, struct_ptr);

-         return;

-      }

-#endif /* PNG_USER_MEM_SUPPORTED */

-      farfree (struct_ptr);

-   }

-}

-

-/* Allocate memory.  For reasonable files, size should never exceed

- * 64K.  However, zlib may allocate more then 64K if you don't tell

- * it not to.  See zconf.h and png.h for more information. zlib does

- * need to allocate exactly 64K, so whatever you call here must

- * have the ability to do that.

- *

- * Borland seems to have a problem in DOS mode for exactly 64K.

- * It gives you a segment with an offset of 8 (perhaps to store its

- * memory stuff).  zlib doesn't like this at all, so we have to

- * detect and deal with it.  This code should not be needed in

- * Windows or OS/2 modes, and only in 16 bit mode.  This code has

- * been updated by Alexander Lehmann for version 0.89 to waste less

- * memory.

- *

- * Note that we can't use png_size_t for the "size" declaration,

- * since on some systems a png_size_t is a 16-bit quantity, and as a

- * result, we would be truncating potentially larger memory requests

- * (which should cause a fatal error) and introducing major problems.

- */

-png_voidp PNGAPI

-png_calloc(png_structp png_ptr, png_uint_32 size)

-{

-   png_voidp ret;

-

-   ret = (png_malloc(png_ptr, size));

-   if (ret != NULL)

-      png_memset(ret,0,(png_size_t)size);

-   return (ret);

-}

-

-png_voidp PNGAPI

-png_malloc(png_structp png_ptr, png_uint_32 size)

-{

-   png_voidp ret;

-

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr->malloc_fn != NULL)

-      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

-   else

-      ret = (png_malloc_default(png_ptr, size));

-   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-       png_error(png_ptr, "Out of memory!");

-   return (ret);

-}

-

-png_voidp PNGAPI

-png_malloc_default(png_structp png_ptr, png_uint_32 size)

-{

-   png_voidp ret;

-#endif /* PNG_USER_MEM_SUPPORTED */

-

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

-

-#ifdef PNG_MAX_MALLOC_64K

-   if (size > (png_uint_32)65536L)

-   {

-      png_warning(png_ptr, "Cannot Allocate > 64K");

-      ret = NULL;

-   }

-   else

-#endif

-

-   if (size != (size_t)size)

-      ret = NULL;

-   else if (size == (png_uint_32)65536L)

-   {

-      if (png_ptr->offset_table == NULL)

-      {

-         /* Try to see if we need to do any of this fancy stuff */

-         ret = farmalloc(size);

-         if (ret == NULL || ((png_size_t)ret & 0xffff))

-         {

-            int num_blocks;

-            png_uint_32 total_size;

-            png_bytep table;

-            int i;

-            png_byte huge * hptr;

-

-            if (ret != NULL)

-            {

-               farfree(ret);

-               ret = NULL;

-            }

-

-            if (png_ptr->zlib_window_bits > 14)

-               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));

-            else

-               num_blocks = 1;

-            if (png_ptr->zlib_mem_level >= 7)

-               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));

-            else

-               num_blocks++;

-

-            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;

-

-            table = farmalloc(total_size);

-

-            if (table == NULL)

-            {

-#ifndef PNG_USER_MEM_SUPPORTED

-               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-                  png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */

-               else

-                  png_warning(png_ptr, "Out Of Memory.");

-#endif

-               return (NULL);

-            }

-

-            if ((png_size_t)table & 0xfff0)

-            {

-#ifndef PNG_USER_MEM_SUPPORTED

-               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-                  png_error(png_ptr,

-                    "Farmalloc didn't return normalized pointer");

-               else

-                  png_warning(png_ptr,

-                    "Farmalloc didn't return normalized pointer");

-#endif

-               return (NULL);

-            }

-

-            png_ptr->offset_table = table;

-            png_ptr->offset_table_ptr = farmalloc(num_blocks *

-               png_sizeof(png_bytep));

-

-            if (png_ptr->offset_table_ptr == NULL)

-            {

-#ifndef PNG_USER_MEM_SUPPORTED

-               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-                  png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */

-               else

-                  png_warning(png_ptr, "Out Of memory.");

-#endif

-               return (NULL);

-            }

-

-            hptr = (png_byte huge *)table;

-            if ((png_size_t)hptr & 0xf)

-            {

-               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);

-               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */

-            }

-            for (i = 0; i < num_blocks; i++)

-            {

-               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;

-               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */

-            }

-

-            png_ptr->offset_table_number = num_blocks;

-            png_ptr->offset_table_count = 0;

-            png_ptr->offset_table_count_free = 0;

-         }

-      }

-

-      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)

-      {

-#ifndef PNG_USER_MEM_SUPPORTED

-         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-            png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */

-         else

-            png_warning(png_ptr, "Out of Memory.");

-#endif

-         return (NULL);

-      }

-

-      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];

-   }

-   else

-      ret = farmalloc(size);

-

-#ifndef PNG_USER_MEM_SUPPORTED

-   if (ret == NULL)

-   {

-      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-         png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */

-      else

-         png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */

-   }

-#endif

-

-   return (ret);

-}

-

-/* Free a pointer allocated by png_malloc().  In the default

- * configuration, png_ptr is not used, but is passed in case it

- * is needed.  If ptr is NULL, return without taking any action.

- */

-void PNGAPI

-png_free(png_structp png_ptr, png_voidp ptr)

-{

-   if (png_ptr == NULL || ptr == NULL)

-      return;

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr->free_fn != NULL)

-   {

-      (*(png_ptr->free_fn))(png_ptr, ptr);

-      return;

-   }

-   else

-      png_free_default(png_ptr, ptr);

-}

-

-void PNGAPI

-png_free_default(png_structp png_ptr, png_voidp ptr)

-{

-#endif /* PNG_USER_MEM_SUPPORTED */

-

-   if (png_ptr == NULL || ptr == NULL)

-      return;

-

-   if (png_ptr->offset_table != NULL)

-   {

-      int i;

-

-      for (i = 0; i < png_ptr->offset_table_count; i++)

-      {

-         if (ptr == png_ptr->offset_table_ptr[i])

-         {

-            ptr = NULL;

-            png_ptr->offset_table_count_free++;

-            break;

-         }

-      }

-      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)

-      {

-         farfree(png_ptr->offset_table);

-         farfree(png_ptr->offset_table_ptr);

-         png_ptr->offset_table = NULL;

-         png_ptr->offset_table_ptr = NULL;

-      }

-   }

-

-   if (ptr != NULL)

-   {

-      farfree(ptr);

-   }

-}

-

-#else /* Not the Borland DOS special memory handler */

-

-/* Allocate memory for a png_struct or a png_info.  The malloc and

-   memset can be replaced by a single call to calloc() if this is thought

-   to improve performance noticably. */

-png_voidp /* PRIVATE */

-png_create_struct(int type)

-{

-#ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));

-}

-

-/* Allocate memory for a png_struct or a png_info.  The malloc and

-   memset can be replaced by a single call to calloc() if this is thought

-   to improve performance noticably. */

-png_voidp /* PRIVATE */

-png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)

-{

-#endif /* PNG_USER_MEM_SUPPORTED */

-   png_size_t size;

-   png_voidp struct_ptr;

-

-   if (type == PNG_STRUCT_INFO)

-      size = png_sizeof(png_info);

-   else if (type == PNG_STRUCT_PNG)

-      size = png_sizeof(png_struct);

-   else

-      return (NULL);

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   if (malloc_fn != NULL)

-   {

-      png_struct dummy_struct;

-      png_structp png_ptr = &dummy_struct;

-      png_ptr->mem_ptr=mem_ptr;

-      struct_ptr = (*(malloc_fn))(png_ptr, size);

-      if (struct_ptr != NULL)

-         png_memset(struct_ptr, 0, size);

-      return (struct_ptr);

-   }

-#endif /* PNG_USER_MEM_SUPPORTED */

-

-#if defined(__TURBOC__) && !defined(__FLAT__)

-   struct_ptr = (png_voidp)farmalloc(size);

-#else

-# if defined(_MSC_VER) && defined(MAXSEG_64K)

-   struct_ptr = (png_voidp)halloc(size, 1);

-# else

-   struct_ptr = (png_voidp)malloc(size);

-# endif

-#endif

-   if (struct_ptr != NULL)

-      png_memset(struct_ptr, 0, size);

-

-   return (struct_ptr);

-}

-

-

-/* Free memory allocated by a png_create_struct() call */

-void /* PRIVATE */

-png_destroy_struct(png_voidp struct_ptr)

-{

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);

-}

-

-/* Free memory allocated by a png_create_struct() call */

-void /* PRIVATE */

-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,

-    png_voidp mem_ptr)

-{

-#endif /* PNG_USER_MEM_SUPPORTED */

-   if (struct_ptr != NULL)

-   {

-#ifdef PNG_USER_MEM_SUPPORTED

-      if (free_fn != NULL)

-      {

-         png_struct dummy_struct;

-         png_structp png_ptr = &dummy_struct;

-         png_ptr->mem_ptr=mem_ptr;

-         (*(free_fn))(png_ptr, struct_ptr);

-         return;

-      }

-#endif /* PNG_USER_MEM_SUPPORTED */

-#if defined(__TURBOC__) && !defined(__FLAT__)

-      farfree(struct_ptr);

-#else

-# if defined(_MSC_VER) && defined(MAXSEG_64K)

-      hfree(struct_ptr);

-# else

-      free(struct_ptr);

-# endif

-#endif

-   }

-}

-

-/* Allocate memory.  For reasonable files, size should never exceed

- * 64K.  However, zlib may allocate more then 64K if you don't tell

- * it not to.  See zconf.h and png.h for more information.  zlib does

- * need to allocate exactly 64K, so whatever you call here must

- * have the ability to do that.

- */

-

-png_voidp PNGAPI

-png_calloc(png_structp png_ptr, png_uint_32 size)

-{

-   png_voidp ret;

-

-   ret = (png_malloc(png_ptr, size));

-   if (ret != NULL)

-      png_memset(ret,0,(png_size_t)size);

-   return (ret);

-}

-

-png_voidp PNGAPI

-png_malloc(png_structp png_ptr, png_uint_32 size)

-{

-   png_voidp ret;

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

-

-   if (png_ptr->malloc_fn != NULL)

-      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

-   else

-      ret = (png_malloc_default(png_ptr, size));

-   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-       png_error(png_ptr, "Out of Memory!");

-   return (ret);

-}

-

-png_voidp PNGAPI

-png_malloc_default(png_structp png_ptr, png_uint_32 size)

-{

-   png_voidp ret;

-#endif /* PNG_USER_MEM_SUPPORTED */

-

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

-

-#ifdef PNG_MAX_MALLOC_64K

-   if (size > (png_uint_32)65536L)

-   {

-#ifndef PNG_USER_MEM_SUPPORTED

-      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-         png_error(png_ptr, "Cannot Allocate > 64K");

-      else

-#endif

-         return NULL;

-   }

-#endif

-

-   /* Check for overflow */

-#if defined(__TURBOC__) && !defined(__FLAT__)

-   if (size != (unsigned long)size)

-      ret = NULL;

-   else

-      ret = farmalloc(size);

-#else

-# if defined(_MSC_VER) && defined(MAXSEG_64K)

-   if (size != (unsigned long)size)

-      ret = NULL;

-   else

-      ret = halloc(size, 1);

-# else

-   if (size != (size_t)size)

-      ret = NULL;

-   else

-      ret = malloc((size_t)size);

-# endif

-#endif

-

-#ifndef PNG_USER_MEM_SUPPORTED

-   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-      png_error(png_ptr, "Out of Memory");

-#endif

-

-   return (ret);

-}

-

-/* Free a pointer allocated by png_malloc().  If ptr is NULL, return

- * without taking any action.

- */

-void PNGAPI

-png_free(png_structp png_ptr, png_voidp ptr)

-{

-   if (png_ptr == NULL || ptr == NULL)

-      return;

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr->free_fn != NULL)

-   {

-      (*(png_ptr->free_fn))(png_ptr, ptr);

-      return;

-   }

-   else

-      png_free_default(png_ptr, ptr);

-}

-void PNGAPI

-png_free_default(png_structp png_ptr, png_voidp ptr)

-{

-   if (png_ptr == NULL || ptr == NULL)

-      return;

-

-#endif /* PNG_USER_MEM_SUPPORTED */

-

-#if defined(__TURBOC__) && !defined(__FLAT__)

-   farfree(ptr);

-#else

-# if defined(_MSC_VER) && defined(MAXSEG_64K)

-   hfree(ptr);

-# else

-   free(ptr);

-# endif

-#endif

-}

-

-#endif /* Not Borland DOS special memory handler */

-

-#ifdef PNG_1_0_X

-#  define png_malloc_warn png_malloc

-#else

-/* This function was added at libpng version 1.2.3.  The png_malloc_warn()

- * function will set up png_malloc() to issue a png_warning and return NULL

- * instead of issuing a png_error, if it fails to allocate the requested

- * memory.

- */

-png_voidp PNGAPI

-png_malloc_warn(png_structp png_ptr, png_uint_32 size)

-{

-   png_voidp ptr;

-   png_uint_32 save_flags;

-   if (png_ptr == NULL)

-      return (NULL);

-

-   save_flags = png_ptr->flags;

-   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;

-   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);

-   png_ptr->flags=save_flags;

-   return(ptr);

-}

-#endif

-

-png_voidp PNGAPI

-png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,

-   png_uint_32 length)

-{

-   png_size_t size;

-

-   size = (png_size_t)length;

-   if ((png_uint_32)size != length)

-      png_error(png_ptr, "Overflow in png_memcpy_check.");

-

-   return(png_memcpy (s1, s2, size));

-}

-

-png_voidp PNGAPI

-png_memset_check (png_structp png_ptr, png_voidp s1, int value,

-   png_uint_32 length)

-{

-   png_size_t size;

-

-   size = (png_size_t)length;

-   if ((png_uint_32)size != length)

-      png_error(png_ptr, "Overflow in png_memset_check.");

-

-   return (png_memset (s1, value, size));

-

-}

-

-#ifdef PNG_USER_MEM_SUPPORTED

-/* This function is called when the application wants to use another method

- * of allocating and freeing memory.

- */

-void PNGAPI

-png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr

-  malloc_fn, png_free_ptr free_fn)

-{

-   if (png_ptr != NULL)

-   {

-      png_ptr->mem_ptr = mem_ptr;

-      png_ptr->malloc_fn = malloc_fn;

-      png_ptr->free_fn = free_fn;

-   }

-}

-

-/* This function returns a pointer to the mem_ptr associated with the user

- * functions.  The application should free any memory associated with this

- * pointer before png_write_destroy and png_read_destroy are called.

- */

-png_voidp PNGAPI

-png_get_mem_ptr(png_structp png_ptr)

-{

-   if (png_ptr == NULL)

-      return (NULL);

-   return ((png_voidp)png_ptr->mem_ptr);

-}

-#endif /* PNG_USER_MEM_SUPPORTED */

-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

+
+/* pngmem.c - stub functions for memory allocation
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all memory allocation.  Users who
+ * need special memory handling are expected to supply replacement
+ * functions for png_malloc() and png_free(), and to use
+ * png_create_read_struct_2() and png_create_write_struct_2() to
+ * identify the replacement functions.
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#include "pngpriv.h"
+
+/* Borland DOS special memory handler */
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+/* If you change this, be sure to change the one in png.h also */
+
+/* Allocate memory for a png_struct.  The malloc and memset can be replaced
+   by a single call to calloc() if this is thought to improve performance. */
+png_voidp /* PRIVATE */
+png_create_struct(int type)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL, NULL));
+}
+
+/* Alternate version of png_create_struct, for use with user-defined malloc. */
+png_voidp /* PRIVATE */
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+   png_size_t size;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+      size = png_sizeof(png_info);
+   else if (type == PNG_STRUCT_PNG)
+      size = png_sizeof(png_struct);
+   else
+      return (png_get_copyright(NULL));
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (malloc_fn != NULL)
+   {
+      png_struct dummy_struct;
+      png_structp png_ptr = &dummy_struct;
+      png_ptr->mem_ptr=mem_ptr;
+      struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
+   }
+   else
+#endif /* PNG_USER_MEM_SUPPORTED */
+   struct_ptr = (png_voidp)farmalloc(size);
+   if (struct_ptr != NULL)
+      png_memset(struct_ptr, 0, size);
+   return (struct_ptr);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct(png_voidp struct_ptr)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, NULL, NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+    png_voidp mem_ptr)
+{
+#endif
+   if (struct_ptr != NULL)
+   {
+#ifdef PNG_USER_MEM_SUPPORTED
+      if (free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
+         (*(free_fn))(png_ptr, struct_ptr);
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */
+      farfree (struct_ptr);
+   }
+}
+
+/* Allocate memory.  For reasonable files, size should never exceed
+ * 64K.  However, zlib may allocate more then 64K if you don't tell
+ * it not to.  See zconf.h and png.h for more information. zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ *
+ * Borland seems to have a problem in DOS mode for exactly 64K.
+ * It gives you a segment with an offset of 8 (perhaps to store its
+ * memory stuff).  zlib doesn't like this at all, so we have to
+ * detect and deal with it.  This code should not be needed in
+ * Windows or OS/2 modes, and only in 16 bit mode.  This code has
+ * been updated by Alexander Lehmann for version 0.89 to waste less
+ * memory.
+ *
+ * Note that we can't use png_size_t for the "size" declaration,
+ * since on some systems a png_size_t is a 16-bit quantity, and as a
+ * result, we would be truncating potentially larger memory requests
+ * (which should cause a fatal error) and introducing major problems.
+ */
+png_voidp PNGAPI
+png_calloc(png_structp png_ptr, png_alloc_size_t size)
+{
+   png_voidp ret;
+
+   ret = (png_malloc(png_ptr, size));
+   if (ret != NULL)
+      png_memset(ret,0,(png_size_t)size);
+   return (ret);
+}
+
+png_voidp PNGAPI
+png_malloc(png_structp png_ptr, png_alloc_size_t size)
+{
+   png_voidp ret;
+
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->malloc_fn != NULL)
+      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+   else
+      ret = (png_malloc_default(png_ptr, size));
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+       png_error(png_ptr, "Out of memory");
+   return (ret);
+}
+
+png_voidp PNGAPI
+png_malloc_default(png_structp png_ptr, png_alloc_size_t size)
+{
+   png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (size > (png_uint_32)65536L)
+   {
+      png_warning(png_ptr, "Cannot Allocate > 64K");
+      ret = NULL;
+   }
+   else
+#endif
+
+   if (size != (size_t)size)
+      ret = NULL;
+   else if (size == (png_uint_32)65536L)
+   {
+      if (png_ptr->offset_table == NULL)
+      {
+         /* Try to see if we need to do any of this fancy stuff */
+         ret = farmalloc(size);
+         if (ret == NULL || ((png_size_t)ret & 0xffff))
+         {
+            int num_blocks;
+            png_uint_32 total_size;
+            png_bytep table;
+            int i;
+            png_byte huge * hptr;
+
+            if (ret != NULL)
+            {
+               farfree(ret);
+               ret = NULL;
+            }
+
+            if (png_ptr->zlib_window_bits > 14)
+               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
+            else
+               num_blocks = 1;
+            if (png_ptr->zlib_mem_level >= 7)
+               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
+            else
+               num_blocks++;
+
+            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
+
+            table = farmalloc(total_size);
+
+            if (table == NULL)
+            {
+#ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr, "Out Of Memory"); /* Note "O" and "M" */
+               else
+                  png_warning(png_ptr, "Out Of Memory");
+#endif
+               return (NULL);
+            }
+
+            if ((png_size_t)table & 0xfff0)
+            {
+#ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr,
+                    "Farmalloc didn't return normalized pointer");
+               else
+                  png_warning(png_ptr,
+                    "Farmalloc didn't return normalized pointer");
+#endif
+               return (NULL);
+            }
+
+            png_ptr->offset_table = table;
+            png_ptr->offset_table_ptr = farmalloc(num_blocks *
+               png_sizeof(png_bytep));
+
+            if (png_ptr->offset_table_ptr == NULL)
+            {
+#ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr, "Out Of memory"); /* Note "O" and "M" */
+               else
+                  png_warning(png_ptr, "Out Of memory");
+#endif
+               return (NULL);
+            }
+
+            hptr = (png_byte huge *)table;
+            if ((png_size_t)hptr & 0xf)
+            {
+               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
+            }
+            for (i = 0; i < num_blocks; i++)
+            {
+               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
+            }
+
+            png_ptr->offset_table_number = num_blocks;
+            png_ptr->offset_table_count = 0;
+            png_ptr->offset_table_count_free = 0;
+         }
+      }
+
+      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
+      {
+#ifndef PNG_USER_MEM_SUPPORTED
+         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+            png_error(png_ptr, "Out of Memory"); /* Note "o" and "M" */
+         else
+            png_warning(png_ptr, "Out of Memory");
+#endif
+         return (NULL);
+      }
+
+      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
+   }
+   else
+      ret = farmalloc(size);
+
+#ifndef PNG_USER_MEM_SUPPORTED
+   if (ret == NULL)
+   {
+      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+         png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */
+      else
+         png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */
+   }
+#endif
+
+   return (ret);
+}
+
+/* Free a pointer allocated by png_malloc().  In the default
+ * configuration, png_ptr is not used, but is passed in case it
+ * is needed.  If ptr is NULL, return without taking any action.
+ */
+void PNGAPI
+png_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      return;
+   }
+   else
+      png_free_default(png_ptr, ptr);
+}
+
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+   if (png_ptr->offset_table != NULL)
+   {
+      int i;
+
+      for (i = 0; i < png_ptr->offset_table_count; i++)
+      {
+         if (ptr == png_ptr->offset_table_ptr[i])
+         {
+            ptr = NULL;
+            png_ptr->offset_table_count_free++;
+            break;
+         }
+      }
+      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
+      {
+         farfree(png_ptr->offset_table);
+         farfree(png_ptr->offset_table_ptr);
+         png_ptr->offset_table = NULL;
+         png_ptr->offset_table_ptr = NULL;
+      }
+   }
+
+   if (ptr != NULL)
+   {
+      farfree(ptr);
+   }
+}
+
+#else /* Not the Borland DOS special memory handler */
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably. */
+png_voidp /* PRIVATE */
+png_create_struct(int type)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL, NULL));
+}
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably. */
+png_voidp /* PRIVATE */
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+   png_size_t size;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+      size = png_sizeof(png_info);
+   else if (type == PNG_STRUCT_PNG)
+      size = png_sizeof(png_struct);
+   else
+      return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (malloc_fn != NULL)
+   {
+      png_struct dummy_struct;
+      png_structp png_ptr = &dummy_struct;
+      png_ptr->mem_ptr=mem_ptr;
+      struct_ptr = (*(malloc_fn))(png_ptr, size);
+      if (struct_ptr != NULL)
+         png_memset(struct_ptr, 0, size);
+      return (struct_ptr);
+   }
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   struct_ptr = (png_voidp)farmalloc(size);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   struct_ptr = (png_voidp)halloc(size, 1);
+# else
+   struct_ptr = (png_voidp)malloc(size);
+# endif
+#endif
+   if (struct_ptr != NULL)
+      png_memset(struct_ptr, 0, size);
+
+   return (struct_ptr);
+}
+
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct(png_voidp struct_ptr)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, NULL, NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+    png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+   if (struct_ptr != NULL)
+   {
+#ifdef PNG_USER_MEM_SUPPORTED
+      if (free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
+         (*(free_fn))(png_ptr, struct_ptr);
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */
+#if defined(__TURBOC__) && !defined(__FLAT__)
+      farfree(struct_ptr);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+      hfree(struct_ptr);
+# else
+      free(struct_ptr);
+# endif
+#endif
+   }
+}
+
+/* Allocate memory.  For reasonable files, size should never exceed
+ * 64K.  However, zlib may allocate more then 64K if you don't tell
+ * it not to.  See zconf.h and png.h for more information.  zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ */
+
+png_voidp PNGAPI
+png_calloc(png_structp png_ptr, png_alloc_size_t size)
+{
+   png_voidp ret;
+
+   ret = (png_malloc(png_ptr, size));
+   if (ret != NULL)
+      png_memset(ret,0,(png_size_t)size);
+   return (ret);
+}
+
+png_voidp PNGAPI
+png_malloc(png_structp png_ptr, png_alloc_size_t size)
+{
+   png_voidp ret;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+
+   if (png_ptr->malloc_fn != NULL)
+      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+   else
+      ret = (png_malloc_default(png_ptr, size));
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+       png_error(png_ptr, "Out of Memory");
+   return (ret);
+}
+
+png_voidp PNGAPI
+png_malloc_default(png_structp png_ptr, png_alloc_size_t size)
+{
+   png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (size > (png_uint_32)65536L)
+   {
+#ifndef PNG_USER_MEM_SUPPORTED
+      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+         png_error(png_ptr, "Cannot Allocate > 64K");
+      else
+#endif
+         return NULL;
+   }
+#endif
+
+   /* Check for overflow */
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   if (size != (unsigned long)size)
+      ret = NULL;
+   else
+      ret = farmalloc(size);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   if (size != (unsigned long)size)
+      ret = NULL;
+   else
+      ret = halloc(size, 1);
+# else
+   if (size != (size_t)size)
+      ret = NULL;
+   else
+      ret = malloc((size_t)size);
+# endif
+#endif
+
+#ifndef PNG_USER_MEM_SUPPORTED
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+      png_error(png_ptr, "Out of Memory");
+#endif
+
+   return (ret);
+}
+
+/* Free a pointer allocated by png_malloc().  If ptr is NULL, return
+ * without taking any action.
+ */
+void PNGAPI
+png_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      return;
+   }
+   else
+      png_free_default(png_ptr, ptr);
+}
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   farfree(ptr);
+#else
+# if defined(_MSC_VER) && defined(MAXSEG_64K)
+   hfree(ptr);
+# else
+   free(ptr);
+# endif
+#endif
+}
+
+#endif /* Not Borland DOS special memory handler */
+
+/* This function was added at libpng version 1.2.3.  The png_malloc_warn()
+ * function will set up png_malloc() to issue a png_warning and return NULL
+ * instead of issuing a png_error, if it fails to allocate the requested
+ * memory.
+ */
+png_voidp PNGAPI
+png_malloc_warn(png_structp png_ptr, png_alloc_size_t size)
+{
+   png_voidp ptr;
+   png_uint_32 save_flags;
+   if (png_ptr == NULL)
+      return (NULL);
+
+   save_flags = png_ptr->flags;
+   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
+   png_ptr->flags=save_flags;
+   return(ptr);
+}
+
+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* This function is called when the application wants to use another method
+ * of allocating and freeing memory.
+ */
+void PNGAPI
+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
+  malloc_fn, png_free_ptr free_fn)
+{
+   if (png_ptr != NULL)
+   {
+      png_ptr->mem_ptr = mem_ptr;
+      png_ptr->malloc_fn = malloc_fn;
+      png_ptr->free_fn = free_fn;
+   }
+}
+
+/* This function returns a pointer to the mem_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp PNGAPI
+png_get_mem_ptr(png_structp png_ptr)
+{
+   if (png_ptr == NULL)
+      return (NULL);
+   return ((png_voidp)png_ptr->mem_ptr);
+}
+#endif /* PNG_USER_MEM_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pngpread.c b/src/libpng/pngpread.c
index 2129fd1b8..e3d311107 100644
--- a/src/libpng/pngpread.c
+++ b/src/libpng/pngpread.c
@@ -1,1730 +1,1721 @@
-

-/* pngpread.c - read a png file in push mode

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-

-/* Push model modes */

-#define PNG_READ_SIG_MODE   0

-#define PNG_READ_CHUNK_MODE 1

-#define PNG_READ_IDAT_MODE  2

-#define PNG_SKIP_MODE       3

-#define PNG_READ_tEXt_MODE  4

-#define PNG_READ_zTXt_MODE  5

-#define PNG_READ_DONE_MODE  6

-#define PNG_READ_iTXt_MODE  7

-#define PNG_ERROR_MODE      8

-

-void PNGAPI

-png_process_data(png_structp png_ptr, png_infop info_ptr,

-   png_bytep buffer, png_size_t buffer_size)

-{

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   png_push_restore_buffer(png_ptr, buffer, buffer_size);

-

-   while (png_ptr->buffer_size)

-   {

-      png_process_some_data(png_ptr, info_ptr);

-   }

-}

-

-/* What we do with the incoming data depends on what we were previously

- * doing before we ran out of data...

- */

-void /* PRIVATE */

-png_process_some_data(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr == NULL)

-      return;

-

-   switch (png_ptr->process_mode)

-   {

-      case PNG_READ_SIG_MODE:

-      {

-         png_push_read_sig(png_ptr, info_ptr);

-         break;

-      }

-

-      case PNG_READ_CHUNK_MODE:

-      {

-         png_push_read_chunk(png_ptr, info_ptr);

-         break;

-      }

-

-      case PNG_READ_IDAT_MODE:

-      {

-         png_push_read_IDAT(png_ptr);

-         break;

-      }

-

-#ifdef PNG_READ_tEXt_SUPPORTED

-      case PNG_READ_tEXt_MODE:

-      {

-         png_push_read_tEXt(png_ptr, info_ptr);

-         break;

-      }

-

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-      case PNG_READ_zTXt_MODE:

-      {

-         png_push_read_zTXt(png_ptr, info_ptr);

-         break;

-      }

-

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-      case PNG_READ_iTXt_MODE:

-      {

-         png_push_read_iTXt(png_ptr, info_ptr);

-         break;

-      }

-

-#endif

-      case PNG_SKIP_MODE:

-      {

-         png_push_crc_finish(png_ptr);

-         break;

-      }

-

-      default:

-      {

-         png_ptr->buffer_size = 0;

-         break;

-      }

-   }

-}

-

-/* Read any remaining signature bytes from the stream and compare them with

- * the correct PNG signature.  It is possible that this routine is called

- * with bytes already read from the signature, either because they have been

- * checked by the calling application, or because of multiple calls to this

- * routine.

- */

-void /* PRIVATE */

-png_push_read_sig(png_structp png_ptr, png_infop info_ptr)

-{

-   png_size_t num_checked = png_ptr->sig_bytes,

-             num_to_check = 8 - num_checked;

-

-   if (png_ptr->buffer_size < num_to_check)

-   {

-      num_to_check = png_ptr->buffer_size;

-   }

-

-   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),

-      num_to_check);

-   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);

-

-   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

-   {

-      if (num_checked < 4 &&

-          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

-         png_error(png_ptr, "Not a PNG file");

-      else

-         png_error(png_ptr, "PNG file corrupted by ASCII conversion");

-   }

-   else

-   {

-      if (png_ptr->sig_bytes >= 8)

-      {

-         png_ptr->process_mode = PNG_READ_CHUNK_MODE;

-      }

-   }

-}

-

-void /* PRIVATE */

-png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-      PNG_CONST PNG_IHDR;

-      PNG_CONST PNG_IDAT;

-      PNG_CONST PNG_IEND;

-      PNG_CONST PNG_PLTE;

-#ifdef PNG_READ_bKGD_SUPPORTED

-      PNG_CONST PNG_bKGD;

-#endif

-#ifdef PNG_READ_cHRM_SUPPORTED

-      PNG_CONST PNG_cHRM;

-#endif

-#ifdef PNG_READ_gAMA_SUPPORTED

-      PNG_CONST PNG_gAMA;

-#endif

-#ifdef PNG_READ_hIST_SUPPORTED

-      PNG_CONST PNG_hIST;

-#endif

-#ifdef PNG_READ_iCCP_SUPPORTED

-      PNG_CONST PNG_iCCP;

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-      PNG_CONST PNG_iTXt;

-#endif

-#ifdef PNG_READ_oFFs_SUPPORTED

-      PNG_CONST PNG_oFFs;

-#endif

-#ifdef PNG_READ_pCAL_SUPPORTED

-      PNG_CONST PNG_pCAL;

-#endif

-#ifdef PNG_READ_pHYs_SUPPORTED

-      PNG_CONST PNG_pHYs;

-#endif

-#ifdef PNG_READ_sBIT_SUPPORTED

-      PNG_CONST PNG_sBIT;

-#endif

-#ifdef PNG_READ_sCAL_SUPPORTED

-      PNG_CONST PNG_sCAL;

-#endif

-#ifdef PNG_READ_sRGB_SUPPORTED

-      PNG_CONST PNG_sRGB;

-#endif

-#ifdef PNG_READ_sPLT_SUPPORTED

-      PNG_CONST PNG_sPLT;

-#endif

-#ifdef PNG_READ_tEXt_SUPPORTED

-      PNG_CONST PNG_tEXt;

-#endif

-#ifdef PNG_READ_tIME_SUPPORTED

-      PNG_CONST PNG_tIME;

-#endif

-#ifdef PNG_READ_tRNS_SUPPORTED

-      PNG_CONST PNG_tRNS;

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-      PNG_CONST PNG_zTXt;

-#endif

-#endif /* PNG_USE_LOCAL_ARRAYS */

-

-   /* First we make sure we have enough data for the 4 byte chunk name

-    * and the 4 byte chunk length before proceeding with decoding the

-    * chunk data.  To fully decode each of these chunks, we also make

-    * sure we have enough data in the buffer for the 4 byte CRC at the

-    * end of every chunk (except IDAT, which is handled separately).

-    */

-   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

-   {

-      png_byte chunk_length[4];

-

-      if (png_ptr->buffer_size < 8)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_fill_buffer(png_ptr, chunk_length, 4);

-      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);

-      png_reset_crc(png_ptr);

-      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

-      png_check_chunk_name(png_ptr, png_ptr->chunk_name);

-      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

-   }

-

-   if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-     if (png_ptr->mode & PNG_AFTER_IDAT)

-        png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

-

-   if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

-   {

-      if (png_ptr->push_length != 13)

-         png_error(png_ptr, "Invalid IHDR length");

-

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-   else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);

-

-      png_ptr->process_mode = PNG_READ_DONE_MODE;

-      png_push_have_end(png_ptr, info_ptr);

-   }

-

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-   else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-         png_ptr->mode |= PNG_HAVE_IDAT;

-

-      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);

-

-      if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

-         png_ptr->mode |= PNG_HAVE_PLTE;

-

-      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-      {

-         if (!(png_ptr->mode & PNG_HAVE_IHDR))

-            png_error(png_ptr, "Missing IHDR before IDAT");

-

-         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

-                  !(png_ptr->mode & PNG_HAVE_PLTE))

-            png_error(png_ptr, "Missing PLTE before IDAT");

-      }

-   }

-

-#endif

-   else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-   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

-       * header chunks, and we can start reading the image (or if this

-       * is called after the image has been read - we have an error).

-       */

-

-      if (!(png_ptr->mode & PNG_HAVE_IHDR))

-         png_error(png_ptr, "Missing IHDR before IDAT");

-

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

-          !(png_ptr->mode & PNG_HAVE_PLTE))

-         png_error(png_ptr, "Missing PLTE before IDAT");

-

-      if (png_ptr->mode & PNG_HAVE_IDAT)

-      {

-         if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

-            if (png_ptr->push_length == 0)

-               return;

-

-         if (png_ptr->mode & PNG_AFTER_IDAT)

-            png_error(png_ptr, "Too many IDAT's found");

-      }

-

-      png_ptr->idat_size = png_ptr->push_length;

-      png_ptr->mode |= PNG_HAVE_IDAT;

-      png_ptr->process_mode = PNG_READ_IDAT_MODE;

-      png_push_have_info(png_ptr, info_ptr);

-      png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;

-      png_ptr->zstream.next_out = png_ptr->row_buf;

-      return;

-   }

-

-#ifdef PNG_READ_gAMA_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_sBIT_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_cHRM_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_sRGB_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_iCCP_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_sPLT_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_tRNS_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_bKGD_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_hIST_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_pHYs_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_oFFs_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);

-   }

-#endif

-

-#ifdef PNG_READ_pCAL_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_sCAL_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_tIME_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_tEXt_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-#endif

-   else

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-      png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-   png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

-}

-

-void /* PRIVATE */

-png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)

-{

-   png_ptr->process_mode = PNG_SKIP_MODE;

-   png_ptr->skip_length = skip;

-}

-

-void /* PRIVATE */

-png_push_crc_finish(png_structp png_ptr)

-{

-   if (png_ptr->skip_length && png_ptr->save_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)

-         save_size = (png_size_t)png_ptr->skip_length;

-      else

-         save_size = png_ptr->save_buffer_size;

-

-      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);

-

-      png_ptr->skip_length -= save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->save_buffer_size -= save_size;

-      png_ptr->save_buffer_ptr += save_size;

-   }

-   if (png_ptr->skip_length && png_ptr->current_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)

-         save_size = (png_size_t)png_ptr->skip_length;

-      else

-         save_size = png_ptr->current_buffer_size;

-

-      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

-

-      png_ptr->skip_length -= save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->current_buffer_size -= save_size;

-      png_ptr->current_buffer_ptr += save_size;

-   }

-   if (!png_ptr->skip_length)

-   {

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_crc_finish(png_ptr, 0);

-      png_ptr->process_mode = PNG_READ_CHUNK_MODE;

-   }

-}

-

-void PNGAPI

-png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)

-{

-   png_bytep ptr;

-

-   if (png_ptr == NULL)

-      return;

-

-   ptr = buffer;

-   if (png_ptr->save_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (length < png_ptr->save_buffer_size)

-         save_size = length;

-      else

-         save_size = png_ptr->save_buffer_size;

-

-      png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);

-      length -= save_size;

-      ptr += save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->save_buffer_size -= save_size;

-      png_ptr->save_buffer_ptr += save_size;

-   }

-   if (length && png_ptr->current_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (length < png_ptr->current_buffer_size)

-         save_size = length;

-

-      else

-         save_size = png_ptr->current_buffer_size;

-

-      png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);

-      png_ptr->buffer_size -= save_size;

-      png_ptr->current_buffer_size -= save_size;

-      png_ptr->current_buffer_ptr += save_size;

-   }

-}

-

-void /* PRIVATE */

-png_push_save_buffer(png_structp png_ptr)

-{

-   if (png_ptr->save_buffer_size)

-   {

-      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)

-      {

-         png_size_t i, istop;

-         png_bytep sp;

-         png_bytep dp;

-

-         istop = png_ptr->save_buffer_size;

-         for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;

-            i < istop; i++, sp++, dp++)

-         {

-            *dp = *sp;

-         }

-      }

-   }

-   if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >

-      png_ptr->save_buffer_max)

-   {

-      png_size_t new_max;

-      png_bytep old_buffer;

-

-      if (png_ptr->save_buffer_size > PNG_SIZE_MAX -

-         (png_ptr->current_buffer_size + 256))

-      {

-        png_error(png_ptr, "Potential overflow of save_buffer");

-      }

-

-      new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;

-      old_buffer = png_ptr->save_buffer;

-      png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,

-         (png_uint_32)new_max);

-      png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);

-      png_free(png_ptr, old_buffer);

-      png_ptr->save_buffer_max = new_max;

-   }

-   if (png_ptr->current_buffer_size)

-   {

-      png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,

-         png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);

-      png_ptr->save_buffer_size += png_ptr->current_buffer_size;

-      png_ptr->current_buffer_size = 0;

-   }

-   png_ptr->save_buffer_ptr = png_ptr->save_buffer;

-   png_ptr->buffer_size = 0;

-}

-

-void /* PRIVATE */

-png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,

-   png_size_t buffer_length)

-{

-   png_ptr->current_buffer = buffer;

-   png_ptr->current_buffer_size = buffer_length;

-   png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;

-   png_ptr->current_buffer_ptr = png_ptr->current_buffer;

-}

-

-void /* PRIVATE */

-png_push_read_IDAT(png_structp png_ptr)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_CONST PNG_IDAT;

-#endif

-   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

-   {

-      png_byte chunk_length[4];

-

-      if (png_ptr->buffer_size < 8)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_fill_buffer(png_ptr, chunk_length, 4);

-      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);

-      png_reset_crc(png_ptr);

-      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

-      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

-

-      if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-      {

-         png_ptr->process_mode = PNG_READ_CHUNK_MODE;

-         if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

-            png_error(png_ptr, "Not enough compressed data");

-         return;

-      }

-

-      png_ptr->idat_size = png_ptr->push_length;

-   }

-   if (png_ptr->idat_size && png_ptr->save_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)

-      {

-         save_size = (png_size_t)png_ptr->idat_size;

-

-         /* Check for overflow */

-         if ((png_uint_32)save_size != png_ptr->idat_size)

-            png_error(png_ptr, "save_size overflowed in pngpread");

-      }

-      else

-         save_size = png_ptr->save_buffer_size;

-

-      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);

-

-      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

-         png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);

-

-      png_ptr->idat_size -= save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->save_buffer_size -= save_size;

-      png_ptr->save_buffer_ptr += save_size;

-   }

-   if (png_ptr->idat_size && png_ptr->current_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)

-      {

-         save_size = (png_size_t)png_ptr->idat_size;

-

-         /* Check for overflow */

-         if ((png_uint_32)save_size != png_ptr->idat_size)

-            png_error(png_ptr, "save_size overflowed in pngpread");

-      }

-      else

-         save_size = png_ptr->current_buffer_size;

-

-      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

-      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

-        png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);

-

-      png_ptr->idat_size -= save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->current_buffer_size -= save_size;

-      png_ptr->current_buffer_ptr += save_size;

-   }

-   if (!png_ptr->idat_size)

-   {

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_crc_finish(png_ptr, 0);

-      png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

-      png_ptr->mode |= PNG_AFTER_IDAT;

-   }

-}

-

-void /* PRIVATE */

-png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,

-   png_size_t buffer_length)

-{

-   int ret;

-

-   if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)

-      png_error(png_ptr, "Extra compression data");

-

-   png_ptr->zstream.next_in = buffer;

-   png_ptr->zstream.avail_in = (uInt)buffer_length;

-   for (;;)

-   {

-      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-      if (ret != Z_OK)

-      {

-         if (ret == Z_STREAM_END)

-         {

-            if (png_ptr->zstream.avail_in)

-               png_error(png_ptr, "Extra compressed data");

-

-            if (!(png_ptr->zstream.avail_out))

-            {

-               png_push_process_row(png_ptr);

-            }

-

-            png_ptr->mode |= PNG_AFTER_IDAT;

-            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-            break;

-         }

-         else if (ret == Z_BUF_ERROR)

-            break;

-

-         else

-            png_error(png_ptr, "Decompression Error");

-      }

-      if (!(png_ptr->zstream.avail_out))

-      {

-         if ((

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-             png_ptr->interlaced && png_ptr->pass > 6) ||

-             (!png_ptr->interlaced &&

-#endif

-             png_ptr->row_number == png_ptr->num_rows))

-         {

-           if (png_ptr->zstream.avail_in)

-             png_warning(png_ptr, "Too much data in IDAT chunks");

-           png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-           break;

-         }

-         png_push_process_row(png_ptr);

-         png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;

-         png_ptr->zstream.next_out = png_ptr->row_buf;

-      }

-

-      else

-         break;

-   }

-}

-

-void /* PRIVATE */

-png_push_process_row(png_structp png_ptr)

-{

-   png_ptr->row_info.color_type = png_ptr->color_type;

-   png_ptr->row_info.width = png_ptr->iwidth;

-   png_ptr->row_info.channels = png_ptr->channels;

-   png_ptr->row_info.bit_depth = png_ptr->bit_depth;

-   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

-

-   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-       png_ptr->row_info.width);

-

-   png_read_filter_row(png_ptr, &(png_ptr->row_info),

-      png_ptr->row_buf + 1, png_ptr->prev_row + 1,

-      (int)(png_ptr->row_buf[0]));

-

-   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,

-      png_ptr->rowbytes + 1);

-

-   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

-      png_do_read_transformations(png_ptr);

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* Blow up interlaced rows to full size */

-   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

-   {

-      if (png_ptr->pass < 6)

-/*       old interface (pre-1.0.9):

-         png_do_read_interlace(&(png_ptr->row_info),

-            png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);

- */

-         png_do_read_interlace(png_ptr);

-

-    switch (png_ptr->pass)

-    {

-         case 0:

-         {

-            int i;

-            for (i = 0; i < 8 && png_ptr->pass == 0; i++)

-            {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */

-            }

-

-            if (png_ptr->pass == 2) /* Pass 1 might be empty */

-            {

-               for (i = 0; i < 4 && png_ptr->pass == 2; i++)

-               {

-                  png_push_have_row(png_ptr, png_bytep_NULL);

-                  png_read_push_finish_row(png_ptr);

-               }

-            }

-

-            if (png_ptr->pass == 4 && png_ptr->height <= 4)

-            {

-               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-               {

-                  png_push_have_row(png_ptr, png_bytep_NULL);

-                  png_read_push_finish_row(png_ptr);

-               }

-            }

-

-            if (png_ptr->pass == 6 && png_ptr->height <= 4)

-            {

-                png_push_have_row(png_ptr, png_bytep_NULL);

-                png_read_push_finish_row(png_ptr);

-            }

-

-            break;

-         }

-

-         case 1:

-         {

-            int i;

-            for (i = 0; i < 8 && png_ptr->pass == 1; i++)

-            {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            if (png_ptr->pass == 2) /* Skip top 4 generated rows */

-            {

-               for (i = 0; i < 4 && png_ptr->pass == 2; i++)

-               {

-                  png_push_have_row(png_ptr, png_bytep_NULL);

-                  png_read_push_finish_row(png_ptr);

-               }

-            }

-

-            break;

-         }

-

-         case 2:

-         {

-            int i;

-

-            for (i = 0; i < 4 && png_ptr->pass == 2; i++)

-            {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            for (i = 0; i < 4 && png_ptr->pass == 2; i++)

-            {

-               png_push_have_row(png_ptr, png_bytep_NULL);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            if (png_ptr->pass == 4) /* Pass 3 might be empty */

-            {

-               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-               {

-                  png_push_have_row(png_ptr, png_bytep_NULL);

-                  png_read_push_finish_row(png_ptr);

-               }

-            }

-

-            break;

-         }

-

-         case 3:

-         {

-            int i;

-

-            for (i = 0; i < 4 && png_ptr->pass == 3; i++)

-            {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            if (png_ptr->pass == 4) /* Skip top two generated rows */

-            {

-               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-               {

-                  png_push_have_row(png_ptr, png_bytep_NULL);

-                  png_read_push_finish_row(png_ptr);

-               }

-            }

-

-            break;

-         }

-

-         case 4:

-         {

-            int i;

-

-            for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-            {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-            {

-               png_push_have_row(png_ptr, png_bytep_NULL);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            if (png_ptr->pass == 6) /* Pass 5 might be empty */

-            {

-               png_push_have_row(png_ptr, png_bytep_NULL);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            break;

-         }

-

-         case 5:

-         {

-            int i;

-

-            for (i = 0; i < 2 && png_ptr->pass == 5; i++)

-            {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            if (png_ptr->pass == 6) /* Skip top generated row */

-            {

-               png_push_have_row(png_ptr, png_bytep_NULL);

-               png_read_push_finish_row(png_ptr);

-            }

-

-            break;

-         }

-         case 6:

-         {

-            png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-            png_read_push_finish_row(png_ptr);

-

-            if (png_ptr->pass != 6)

-               break;

-

-            png_push_have_row(png_ptr, png_bytep_NULL);

-            png_read_push_finish_row(png_ptr);

-         }

-      }

-   }

-   else

-#endif

-   {

-      png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-      png_read_push_finish_row(png_ptr);

-   }

-}

-

-void /* PRIVATE */

-png_read_push_finish_row(png_structp png_ptr)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-

-   /* Start of interlace block */

-   PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};

-

-   /* Offset to next interlace block */

-   PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};

-

-   /* Start of interlace block in the y direction */

-   PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};

-

-   /* Offset to next interlace block in the y direction */

-   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

-    * it, uncomment it here and in png.h

-   PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};

-   */

-#endif

-

-   png_ptr->row_number++;

-   if (png_ptr->row_number < png_ptr->num_rows)

-      return;

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   if (png_ptr->interlaced)

-   {

-      png_ptr->row_number = 0;

-      png_memset_check(png_ptr, png_ptr->prev_row, 0,

-         png_ptr->rowbytes + 1);

-      do

-      {

-         png_ptr->pass++;

-         if ((png_ptr->pass == 1 && png_ptr->width < 5) ||

-             (png_ptr->pass == 3 && png_ptr->width < 3) ||

-             (png_ptr->pass == 5 && png_ptr->width < 2))

-           png_ptr->pass++;

-

-         if (png_ptr->pass > 7)

-            png_ptr->pass--;

-

-         if (png_ptr->pass >= 7)

-            break;

-

-         png_ptr->iwidth = (png_ptr->width +

-            png_pass_inc[png_ptr->pass] - 1 -

-            png_pass_start[png_ptr->pass]) /

-            png_pass_inc[png_ptr->pass];

-

-         png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,

-            png_ptr->iwidth) + 1;

-

-         if (png_ptr->transformations & PNG_INTERLACE)

-            break;

-

-         png_ptr->num_rows = (png_ptr->height +

-            png_pass_yinc[png_ptr->pass] - 1 -

-            png_pass_ystart[png_ptr->pass]) /

-            png_pass_yinc[png_ptr->pass];

-

-      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);

-   }

-#endif /* PNG_READ_INTERLACING_SUPPORTED */

-}

-

-#ifdef PNG_READ_tEXt_SUPPORTED

-void /* PRIVATE */

-png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

-{

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

-      {

-         png_error(png_ptr, "Out of place tEXt");

-         info_ptr = info_ptr; /* To quiet some compiler warnings */

-      }

-

-#ifdef PNG_MAX_MALLOC_64K

-   png_ptr->skip_length = 0;  /* This may not be necessary */

-

-   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */

-   {

-      png_warning(png_ptr, "tEXt chunk too large to fit in memory");

-      png_ptr->skip_length = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

-      (png_uint_32)(length + 1));

-   png_ptr->current_text[length] = '\0';

-   png_ptr->current_text_ptr = png_ptr->current_text;

-   png_ptr->current_text_size = (png_size_t)length;

-   png_ptr->current_text_left = (png_size_t)length;

-   png_ptr->process_mode = PNG_READ_tEXt_MODE;

-}

-

-void /* PRIVATE */

-png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr->buffer_size && png_ptr->current_text_left)

-   {

-      png_size_t text_size;

-

-      if (png_ptr->buffer_size < png_ptr->current_text_left)

-         text_size = png_ptr->buffer_size;

-

-      else

-         text_size = png_ptr->current_text_left;

-

-      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_ptr += text_size;

-   }

-   if (!(png_ptr->current_text_left))

-   {

-      png_textp text_ptr;

-      png_charp text;

-      png_charp key;

-      int ret;

-

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_crc_finish(png_ptr);

-

-#ifdef PNG_MAX_MALLOC_64K

-      if (png_ptr->skip_length)

-         return;

-#endif

-

-      key = png_ptr->current_text;

-

-      for (text = key; *text; text++)

-         /* Empty loop */ ;

-

-      if (text < key + png_ptr->current_text_size)

-         text++;

-

-      text_ptr = (png_textp)png_malloc(png_ptr,

-         (png_uint_32)png_sizeof(png_text));

-      text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

-      text_ptr->key = key;

-#ifdef PNG_iTXt_SUPPORTED

-      text_ptr->lang = NULL;

-      text_ptr->lang_key = NULL;

-#endif

-      text_ptr->text = text;

-

-      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

-

-      png_free(png_ptr, key);

-      png_free(png_ptr, text_ptr);

-      png_ptr->current_text = NULL;

-

-      if (ret)

-        png_warning(png_ptr, "Insufficient memory to store text chunk.");

-   }

-}

-#endif

-

-#ifdef PNG_READ_zTXt_SUPPORTED

-void /* PRIVATE */

-png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

-{

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

-      {

-         png_error(png_ptr, "Out of place zTXt");

-         info_ptr = info_ptr; /* To quiet some compiler warnings */

-      }

-

-#ifdef PNG_MAX_MALLOC_64K

-   /* We can't handle zTXt chunks > 64K, since we don't have enough space

-    * to be able to store the uncompressed data.  Actually, the threshold

-    * is probably around 32K, but it isn't as definite as 64K is.

-    */

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "zTXt chunk too large to fit in memory");

-      png_push_crc_skip(png_ptr, length);

-      return;

-   }

-#endif

-

-   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

-      (png_uint_32)(length + 1));

-   png_ptr->current_text[length] = '\0';

-   png_ptr->current_text_ptr = png_ptr->current_text;

-   png_ptr->current_text_size = (png_size_t)length;

-   png_ptr->current_text_left = (png_size_t)length;

-   png_ptr->process_mode = PNG_READ_zTXt_MODE;

-}

-

-void /* PRIVATE */

-png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr->buffer_size && png_ptr->current_text_left)

-   {

-      png_size_t text_size;

-

-      if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)

-         text_size = png_ptr->buffer_size;

-

-      else

-         text_size = png_ptr->current_text_left;

-

-      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_ptr += text_size;

-   }

-   if (!(png_ptr->current_text_left))

-   {

-      png_textp text_ptr;

-      png_charp text;

-      png_charp key;

-      int ret;

-      png_size_t text_size, key_size;

-

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_crc_finish(png_ptr);

-

-      key = png_ptr->current_text;

-

-      for (text = key; *text; text++)

-         /* Empty loop */ ;

-

-      /* zTXt can't have zero text */

-      if (text >= key + png_ptr->current_text_size)

-      {

-         png_ptr->current_text = NULL;

-         png_free(png_ptr, key);

-         return;

-      }

-

-      text++;

-

-      if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */

-      {

-         png_ptr->current_text = NULL;

-         png_free(png_ptr, key);

-         return;

-      }

-

-      text++;

-

-      png_ptr->zstream.next_in = (png_bytep )text;

-      png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -

-         (text - key));

-      png_ptr->zstream.next_out = png_ptr->zbuf;

-      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-

-      key_size = text - key;

-      text_size = 0;

-      text = NULL;

-      ret = Z_STREAM_END;

-

-      while (png_ptr->zstream.avail_in)

-      {

-         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-         if (ret != Z_OK && ret != Z_STREAM_END)

-         {

-            inflateReset(&png_ptr->zstream);

-            png_ptr->zstream.avail_in = 0;

-            png_ptr->current_text = NULL;

-            png_free(png_ptr, key);

-            png_free(png_ptr, text);

-            return;

-         }

-         if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)

-         {

-            if (text == NULL)

-            {

-               text = (png_charp)png_malloc(png_ptr,

-                     (png_uint_32)(png_ptr->zbuf_size

-                     - png_ptr->zstream.avail_out + key_size + 1));

-

-               png_memcpy(text + key_size, png_ptr->zbuf,

-                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);

-

-               png_memcpy(text, key, key_size);

-

-               text_size = key_size + png_ptr->zbuf_size -

-                  png_ptr->zstream.avail_out;

-

-               *(text + text_size) = '\0';

-            }

-            else

-            {

-               png_charp tmp;

-

-               tmp = text;

-               text = (png_charp)png_malloc(png_ptr, text_size +

-                  (png_uint_32)(png_ptr->zbuf_size 

-                  - png_ptr->zstream.avail_out + 1));

-

-               png_memcpy(text, tmp, text_size);

-               png_free(png_ptr, tmp);

-

-               png_memcpy(text + text_size, png_ptr->zbuf,

-                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);

-

-               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;

-               *(text + text_size) = '\0';

-            }

-            if (ret != Z_STREAM_END)

-            {

-               png_ptr->zstream.next_out = png_ptr->zbuf;

-               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-            }

-         }

-         else

-         {

-            break;

-         }

-

-         if (ret == Z_STREAM_END)

-            break;

-      }

-

-      inflateReset(&png_ptr->zstream);

-      png_ptr->zstream.avail_in = 0;

-

-      if (ret != Z_STREAM_END)

-      {

-         png_ptr->current_text = NULL;

-         png_free(png_ptr, key);

-         png_free(png_ptr, text);

-         return;

-      }

-

-      png_ptr->current_text = NULL;

-      png_free(png_ptr, key);

-      key = text;

-      text += key_size;

-

-      text_ptr = (png_textp)png_malloc(png_ptr,

-          (png_uint_32)png_sizeof(png_text));

-      text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;

-      text_ptr->key = key;

-#ifdef PNG_iTXt_SUPPORTED

-      text_ptr->lang = NULL;

-      text_ptr->lang_key = NULL;

-#endif

-      text_ptr->text = text;

-

-      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

-

-      png_free(png_ptr, key);

-      png_free(png_ptr, text_ptr);

-

-      if (ret)

-        png_warning(png_ptr, "Insufficient memory to store text chunk.");

-   }

-}

-#endif

-

-#ifdef PNG_READ_iTXt_SUPPORTED

-void /* PRIVATE */

-png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

-{

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

-      {

-         png_error(png_ptr, "Out of place iTXt");

-         info_ptr = info_ptr; /* To quiet some compiler warnings */

-      }

-

-#ifdef PNG_MAX_MALLOC_64K

-   png_ptr->skip_length = 0;  /* This may not be necessary */

-

-   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */

-   {

-      png_warning(png_ptr, "iTXt chunk too large to fit in memory");

-      png_ptr->skip_length = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

-      (png_uint_32)(length + 1));

-   png_ptr->current_text[length] = '\0';

-   png_ptr->current_text_ptr = png_ptr->current_text;

-   png_ptr->current_text_size = (png_size_t)length;

-   png_ptr->current_text_left = (png_size_t)length;

-   png_ptr->process_mode = PNG_READ_iTXt_MODE;

-}

-

-void /* PRIVATE */

-png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)

-{

-

-   if (png_ptr->buffer_size && png_ptr->current_text_left)

-   {

-      png_size_t text_size;

-

-      if (png_ptr->buffer_size < png_ptr->current_text_left)

-         text_size = png_ptr->buffer_size;

-

-      else

-         text_size = png_ptr->current_text_left;

-

-      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_ptr += text_size;

-   }

-   if (!(png_ptr->current_text_left))

-   {

-      png_textp text_ptr;

-      png_charp key;

-      int comp_flag;

-      png_charp lang;

-      png_charp lang_key;

-      png_charp text;

-      int ret;

-

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_crc_finish(png_ptr);

-

-#ifdef PNG_MAX_MALLOC_64K

-      if (png_ptr->skip_length)

-         return;

-#endif

-

-      key = png_ptr->current_text;

-

-      for (lang = key; *lang; lang++)

-         /* Empty loop */ ;

-

-      if (lang < key + png_ptr->current_text_size - 3)

-         lang++;

-

-      comp_flag = *lang++;

-      lang++;     /* Skip comp_type, always zero */

-

-      for (lang_key = lang; *lang_key; lang_key++)

-         /* Empty loop */ ;

-

-      lang_key++;        /* Skip NUL separator */

-

-      text=lang_key;

-

-      if (lang_key < key + png_ptr->current_text_size - 1)

-      {

-        for (; *text; text++)

-           /* Empty loop */ ;

-      }

-

-      if (text < key + png_ptr->current_text_size)

-         text++;

-

-      text_ptr = (png_textp)png_malloc(png_ptr,

-         (png_uint_32)png_sizeof(png_text));

-

-      text_ptr->compression = comp_flag + 2;

-      text_ptr->key = key;

-      text_ptr->lang = lang;

-      text_ptr->lang_key = lang_key;

-      text_ptr->text = text;

-      text_ptr->text_length = 0;

-      text_ptr->itxt_length = png_strlen(text);

-

-      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

-

-      png_ptr->current_text = NULL;

-

-      png_free(png_ptr, text_ptr);

-      if (ret)

-        png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");

-   }

-}

-#endif

-

-/* This function is called when we haven't found a handler for this

- * chunk.  If there isn't a problem with the chunk itself (ie a bad chunk

- * name or a critical chunk), the chunk is (currently) silently ignored.

- */

-void /* PRIVATE */

-png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

-{

-   png_uint_32 skip = 0;

-

-   if (!(png_ptr->chunk_name[0] & 0x20))

-   {

-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-      if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

-         PNG_HANDLE_CHUNK_ALWAYS

-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-         && png_ptr->read_user_chunk_fn == NULL

-#endif

-         )

-#endif

-         png_chunk_error(png_ptr, "unknown critical chunk");

-

-      info_ptr = info_ptr; /* To quiet some compiler warnings */

-   }

-

-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-   if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

-   {

-#ifdef PNG_MAX_MALLOC_64K

-      if (length > (png_uint_32)65535L)

-      {

-          png_warning(png_ptr, "unknown chunk too large to fit in memory");

-          skip = length - (png_uint_32)65535L;

-          length = (png_uint_32)65535L;

-      }

-#endif

-      png_memcpy((png_charp)png_ptr->unknown_chunk.name,

-                 (png_charp)png_ptr->chunk_name, 

-                 png_sizeof(png_ptr->unknown_chunk.name));

-      png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]

-        = '\0';

-

-      png_ptr->unknown_chunk.size = (png_size_t)length;

-

-      if (length == 0)

-         png_ptr->unknown_chunk.data = NULL;

-

-      else

-      {

-         png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,

-       (png_uint_32)length);

-         png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);

-      }

-

-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-      if (png_ptr->read_user_chunk_fn != NULL)

-      {

-         /* Callback to user unknown chunk handler */

-         int ret;

-         ret = (*(png_ptr->read_user_chunk_fn))

-           (png_ptr, &png_ptr->unknown_chunk);

-

-         if (ret < 0)

-            png_chunk_error(png_ptr, "error in user chunk");

-

-         if (ret == 0)

-         {

-            if (!(png_ptr->chunk_name[0] & 0x20))

-               if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

-                    PNG_HANDLE_CHUNK_ALWAYS)

-                  png_chunk_error(png_ptr, "unknown critical chunk");

-            png_set_unknown_chunks(png_ptr, info_ptr,

-               &png_ptr->unknown_chunk, 1);

-         }

-      }

-

-      else

-#endif

-        png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);

-      png_free(png_ptr, png_ptr->unknown_chunk.data);

-      png_ptr->unknown_chunk.data = NULL;

-   }

-

-   else

-#endif

-      skip=length;

-   png_push_crc_skip(png_ptr, skip);

-}

-

-void /* PRIVATE */

-png_push_have_info(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr->info_fn != NULL)

-      (*(png_ptr->info_fn))(png_ptr, info_ptr);

-}

-

-void /* PRIVATE */

-png_push_have_end(png_structp png_ptr, png_infop info_ptr)

-{

-   if (png_ptr->end_fn != NULL)

-      (*(png_ptr->end_fn))(png_ptr, info_ptr);

-}

-

-void /* PRIVATE */

-png_push_have_row(png_structp png_ptr, png_bytep row)

-{

-   if (png_ptr->row_fn != NULL)

-      (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,

-         (int)png_ptr->pass);

-}

-

-void PNGAPI

-png_progressive_combine_row (png_structp png_ptr,

-   png_bytep old_row, png_bytep new_row)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_CONST int FARDATA png_pass_dsp_mask[7] =

-      {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

-#endif

-

-   if (png_ptr == NULL)

-      return;

-

-   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]);

-}

-

-void PNGAPI

-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_end_ptr end_fn)

-{

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->info_fn = info_fn;

-   png_ptr->row_fn = row_fn;

-   png_ptr->end_fn = end_fn;

-

-   png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);

-}

-

-png_voidp PNGAPI

-png_get_progressive_ptr(png_structp png_ptr)

-{

-   if (png_ptr == NULL)

-      return (NULL);

-

-   return png_ptr->io_ptr;

-}

-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

+
+/* pngpread.c - read a png file in push mode
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+#include "pngpriv.h"
+
+/* Push model modes */
+#define PNG_READ_SIG_MODE   0
+#define PNG_READ_CHUNK_MODE 1
+#define PNG_READ_IDAT_MODE  2
+#define PNG_SKIP_MODE       3
+#define PNG_READ_tEXt_MODE  4
+#define PNG_READ_zTXt_MODE  5
+#define PNG_READ_DONE_MODE  6
+#define PNG_READ_iTXt_MODE  7
+#define PNG_ERROR_MODE      8
+
+void PNGAPI
+png_process_data(png_structp png_ptr, png_infop info_ptr,
+   png_bytep buffer, png_size_t buffer_size)
+{
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_push_restore_buffer(png_ptr, buffer, buffer_size);
+
+   while (png_ptr->buffer_size)
+   {
+      png_process_some_data(png_ptr, info_ptr);
+   }
+}
+
+/* What we do with the incoming data depends on what we were previously
+ * doing before we ran out of data...
+ */
+void /* PRIVATE */
+png_process_some_data(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr == NULL)
+      return;
+
+   switch (png_ptr->process_mode)
+   {
+      case PNG_READ_SIG_MODE:
+      {
+         png_push_read_sig(png_ptr, info_ptr);
+         break;
+      }
+
+      case PNG_READ_CHUNK_MODE:
+      {
+         png_push_read_chunk(png_ptr, info_ptr);
+         break;
+      }
+
+      case PNG_READ_IDAT_MODE:
+      {
+         png_push_read_IDAT(png_ptr);
+         break;
+      }
+
+#ifdef PNG_READ_tEXt_SUPPORTED
+      case PNG_READ_tEXt_MODE:
+      {
+         png_push_read_tEXt(png_ptr, info_ptr);
+         break;
+      }
+
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+      case PNG_READ_zTXt_MODE:
+      {
+         png_push_read_zTXt(png_ptr, info_ptr);
+         break;
+      }
+
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+      case PNG_READ_iTXt_MODE:
+      {
+         png_push_read_iTXt(png_ptr, info_ptr);
+         break;
+      }
+
+#endif
+      case PNG_SKIP_MODE:
+      {
+         png_push_crc_finish(png_ptr);
+         break;
+      }
+
+      default:
+      {
+         png_ptr->buffer_size = 0;
+         break;
+      }
+   }
+}
+
+/* Read any remaining signature bytes from the stream and compare them with
+ * the correct PNG signature.  It is possible that this routine is called
+ * with bytes already read from the signature, either because they have been
+ * checked by the calling application, or because of multiple calls to this
+ * routine.
+ */
+void /* PRIVATE */
+png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
+{
+   png_size_t num_checked = png_ptr->sig_bytes,
+             num_to_check = 8 - num_checked;
+
+   if (png_ptr->buffer_size < num_to_check)
+   {
+      num_to_check = png_ptr->buffer_size;
+   }
+
+   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
+      num_to_check);
+   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
+
+   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
+   {
+      if (num_checked < 4 &&
+          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
+         png_error(png_ptr, "Not a PNG file");
+      else
+         png_error(png_ptr, "PNG file corrupted by ASCII conversion");
+   }
+   else
+   {
+      if (png_ptr->sig_bytes >= 8)
+      {
+         png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+      }
+   }
+}
+
+void /* PRIVATE */
+png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
+{
+      PNG_IHDR;
+      PNG_IDAT;
+      PNG_IEND;
+      PNG_PLTE;
+#ifdef PNG_READ_bKGD_SUPPORTED
+      PNG_bKGD;
+#endif
+#ifdef PNG_READ_cHRM_SUPPORTED
+      PNG_cHRM;
+#endif
+#ifdef PNG_READ_gAMA_SUPPORTED
+      PNG_gAMA;
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+      PNG_hIST;
+#endif
+#ifdef PNG_READ_iCCP_SUPPORTED
+      PNG_iCCP;
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+      PNG_iTXt;
+#endif
+#ifdef PNG_READ_oFFs_SUPPORTED
+      PNG_oFFs;
+#endif
+#ifdef PNG_READ_pCAL_SUPPORTED
+      PNG_pCAL;
+#endif
+#ifdef PNG_READ_pHYs_SUPPORTED
+      PNG_pHYs;
+#endif
+#ifdef PNG_READ_sBIT_SUPPORTED
+      PNG_sBIT;
+#endif
+#ifdef PNG_READ_sCAL_SUPPORTED
+      PNG_sCAL;
+#endif
+#ifdef PNG_READ_sRGB_SUPPORTED
+      PNG_sRGB;
+#endif
+#ifdef PNG_READ_sPLT_SUPPORTED
+      PNG_sPLT;
+#endif
+#ifdef PNG_READ_tEXt_SUPPORTED
+      PNG_tEXt;
+#endif
+#ifdef PNG_READ_tIME_SUPPORTED
+      PNG_tIME;
+#endif
+#ifdef PNG_READ_tRNS_SUPPORTED
+      PNG_tRNS;
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+      PNG_zTXt;
+#endif
+
+   /* First we make sure we have enough data for the 4 byte chunk name
+    * and the 4 byte chunk length before proceeding with decoding the
+    * chunk data.  To fully decode each of these chunks, we also make
+    * sure we have enough data in the buffer for the 4 byte CRC at the
+    * end of every chunk (except IDAT, which is handled separately).
+    */
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
+   {
+      png_byte chunk_length[4];
+
+      if (png_ptr->buffer_size < 8)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_fill_buffer(png_ptr, chunk_length, 4);
+      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
+      png_reset_crc(png_ptr);
+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+      png_check_chunk_name(png_ptr, png_ptr->chunk_name);
+      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
+   }
+
+   if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+     if (png_ptr->mode & PNG_AFTER_IDAT)
+        png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
+
+   if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
+   {
+      if (png_ptr->push_length != 13)
+         png_error(png_ptr, "Invalid IHDR length");
+
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+   else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
+
+      png_ptr->process_mode = PNG_READ_DONE_MODE;
+      png_push_have_end(png_ptr, info_ptr);
+   }
+
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+   else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+         png_ptr->mode |= PNG_HAVE_IDAT;
+
+      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
+
+      if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
+         png_ptr->mode |= PNG_HAVE_PLTE;
+
+      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+      {
+         if (!(png_ptr->mode & PNG_HAVE_IHDR))
+            png_error(png_ptr, "Missing IHDR before IDAT");
+
+         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+                  !(png_ptr->mode & PNG_HAVE_PLTE))
+            png_error(png_ptr, "Missing PLTE before IDAT");
+      }
+   }
+
+#endif
+   else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+   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
+       * header chunks, and we can start reading the image (or if this
+       * is called after the image has been read - we have an error).
+       */
+
+      if (!(png_ptr->mode & PNG_HAVE_IHDR))
+         png_error(png_ptr, "Missing IHDR before IDAT");
+
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+          !(png_ptr->mode & PNG_HAVE_PLTE))
+         png_error(png_ptr, "Missing PLTE before IDAT");
+
+      if (png_ptr->mode & PNG_HAVE_IDAT)
+      {
+         if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+            if (png_ptr->push_length == 0)
+               return;
+
+         if (png_ptr->mode & PNG_AFTER_IDAT)
+            png_benign_error(png_ptr, "Too many IDATs found");
+      }
+
+      png_ptr->idat_size = png_ptr->push_length;
+      png_ptr->mode |= PNG_HAVE_IDAT;
+      png_ptr->process_mode = PNG_READ_IDAT_MODE;
+      png_push_have_info(png_ptr, info_ptr);
+      png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
+      png_ptr->zstream.next_out = png_ptr->row_buf;
+      return;
+   }
+
+#ifdef PNG_READ_gAMA_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sBIT_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_cHRM_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sRGB_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_iCCP_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sPLT_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_tRNS_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_bKGD_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_pHYs_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_oFFs_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
+   }
+#endif
+
+#ifdef PNG_READ_pCAL_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sCAL_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_tIME_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_tEXt_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+   else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+   else
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+      png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+   png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
+}
+
+void /* PRIVATE */
+png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
+{
+   png_ptr->process_mode = PNG_SKIP_MODE;
+   png_ptr->skip_length = skip;
+}
+
+void /* PRIVATE */
+png_push_crc_finish(png_structp png_ptr)
+{
+   if (png_ptr->skip_length && png_ptr->save_buffer_size)
+   {
+      png_size_t save_size;
+
+      if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)
+         save_size = (png_size_t)png_ptr->skip_length;
+      else
+         save_size = png_ptr->save_buffer_size;
+
+      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
+
+      png_ptr->skip_length -= save_size;
+      png_ptr->buffer_size -= save_size;
+      png_ptr->save_buffer_size -= save_size;
+      png_ptr->save_buffer_ptr += save_size;
+   }
+   if (png_ptr->skip_length && png_ptr->current_buffer_size)
+   {
+      png_size_t save_size;
+
+      if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)
+         save_size = (png_size_t)png_ptr->skip_length;
+      else
+         save_size = png_ptr->current_buffer_size;
+
+      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
+
+      png_ptr->skip_length -= save_size;
+      png_ptr->buffer_size -= save_size;
+      png_ptr->current_buffer_size -= save_size;
+      png_ptr->current_buffer_ptr += save_size;
+   }
+   if (!png_ptr->skip_length)
+   {
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_crc_finish(png_ptr, 0);
+      png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+   }
+}
+
+void PNGAPI
+png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
+{
+   png_bytep ptr;
+
+   if (png_ptr == NULL)
+      return;
+
+   ptr = buffer;
+   if (png_ptr->save_buffer_size)
+   {
+      png_size_t save_size;
+
+      if (length < png_ptr->save_buffer_size)
+         save_size = length;
+      else
+         save_size = png_ptr->save_buffer_size;
+
+      png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
+      length -= save_size;
+      ptr += save_size;
+      png_ptr->buffer_size -= save_size;
+      png_ptr->save_buffer_size -= save_size;
+      png_ptr->save_buffer_ptr += save_size;
+   }
+   if (length && png_ptr->current_buffer_size)
+   {
+      png_size_t save_size;
+
+      if (length < png_ptr->current_buffer_size)
+         save_size = length;
+
+      else
+         save_size = png_ptr->current_buffer_size;
+
+      png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
+      png_ptr->buffer_size -= save_size;
+      png_ptr->current_buffer_size -= save_size;
+      png_ptr->current_buffer_ptr += save_size;
+   }
+}
+
+void /* PRIVATE */
+png_push_save_buffer(png_structp png_ptr)
+{
+   if (png_ptr->save_buffer_size)
+   {
+      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
+      {
+         png_size_t i, istop;
+         png_bytep sp;
+         png_bytep dp;
+
+         istop = png_ptr->save_buffer_size;
+         for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
+            i < istop; i++, sp++, dp++)
+         {
+            *dp = *sp;
+         }
+      }
+   }
+   if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
+      png_ptr->save_buffer_max)
+   {
+      png_size_t new_max;
+      png_bytep old_buffer;
+
+      if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
+         (png_ptr->current_buffer_size + 256))
+      {
+        png_error(png_ptr, "Potential overflow of save_buffer");
+      }
+
+      new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
+      old_buffer = png_ptr->save_buffer;
+      png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
+         (png_size_t)new_max);
+      png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
+      png_free(png_ptr, old_buffer);
+      png_ptr->save_buffer_max = new_max;
+   }
+   if (png_ptr->current_buffer_size)
+   {
+      png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
+         png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
+      png_ptr->save_buffer_size += png_ptr->current_buffer_size;
+      png_ptr->current_buffer_size = 0;
+   }
+   png_ptr->save_buffer_ptr = png_ptr->save_buffer;
+   png_ptr->buffer_size = 0;
+}
+
+void /* PRIVATE */
+png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
+   png_size_t buffer_length)
+{
+   png_ptr->current_buffer = buffer;
+   png_ptr->current_buffer_size = buffer_length;
+   png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
+   png_ptr->current_buffer_ptr = png_ptr->current_buffer;
+}
+
+void /* PRIVATE */
+png_push_read_IDAT(png_structp png_ptr)
+{
+   PNG_IDAT;
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
+   {
+      png_byte chunk_length[4];
+
+      if (png_ptr->buffer_size < 8)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_fill_buffer(png_ptr, chunk_length, 4);
+      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
+      png_reset_crc(png_ptr);
+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
+
+      if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+      {
+         png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+         if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+            png_error(png_ptr, "Not enough compressed data");
+         return;
+      }
+
+      png_ptr->idat_size = png_ptr->push_length;
+   }
+   if (png_ptr->idat_size && png_ptr->save_buffer_size)
+   {
+      png_size_t save_size;
+
+      if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
+      {
+         save_size = (png_size_t)png_ptr->idat_size;
+
+         /* Check for overflow */
+         if ((png_uint_32)save_size != png_ptr->idat_size)
+            png_error(png_ptr, "save_size overflowed in pngpread");
+      }
+      else
+         save_size = png_ptr->save_buffer_size;
+
+      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
+
+      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+         png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
+
+      png_ptr->idat_size -= save_size;
+      png_ptr->buffer_size -= save_size;
+      png_ptr->save_buffer_size -= save_size;
+      png_ptr->save_buffer_ptr += save_size;
+   }
+   if (png_ptr->idat_size && png_ptr->current_buffer_size)
+   {
+      png_size_t save_size;
+
+      if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
+      {
+         save_size = (png_size_t)png_ptr->idat_size;
+
+         /* Check for overflow */
+         if ((png_uint_32)save_size != png_ptr->idat_size)
+            png_error(png_ptr, "save_size overflowed in pngpread");
+      }
+      else
+         save_size = png_ptr->current_buffer_size;
+
+      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
+      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+        png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
+
+      png_ptr->idat_size -= save_size;
+      png_ptr->buffer_size -= save_size;
+      png_ptr->current_buffer_size -= save_size;
+      png_ptr->current_buffer_ptr += save_size;
+   }
+   if (!png_ptr->idat_size)
+   {
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_crc_finish(png_ptr, 0);
+      png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
+      png_ptr->mode |= PNG_AFTER_IDAT;
+   }
+}
+
+void /* PRIVATE */
+png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
+   png_size_t buffer_length)
+{
+   int ret;
+
+   if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)
+      png_benign_error(png_ptr, "Extra compression data");
+
+   png_ptr->zstream.next_in = buffer;
+   png_ptr->zstream.avail_in = (uInt)buffer_length;
+   for (;;)
+   {
+      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+      if (ret != Z_OK)
+      {
+         if (ret == Z_STREAM_END)
+         {
+            if (png_ptr->zstream.avail_in)
+               png_benign_error(png_ptr, "Extra compressed data");
+
+            if (!(png_ptr->zstream.avail_out))
+            {
+               png_push_process_row(png_ptr);
+            }
+
+            png_ptr->mode |= PNG_AFTER_IDAT;
+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+            break;
+         }
+         else if (ret == Z_BUF_ERROR)
+            break;
+
+         else
+            png_error(png_ptr, "Decompression Error");
+      }
+      if (!(png_ptr->zstream.avail_out))
+      {
+         if ((
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+             png_ptr->interlaced && png_ptr->pass > 6) ||
+             (!png_ptr->interlaced &&
+#endif
+             png_ptr->row_number == png_ptr->num_rows))
+         {
+           if (png_ptr->zstream.avail_in)
+             png_warning(png_ptr, "Too much data in IDAT chunks");
+           png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+           break;
+         }
+         png_push_process_row(png_ptr);
+         png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
+         png_ptr->zstream.next_out = png_ptr->row_buf;
+      }
+
+      else
+         break;
+   }
+}
+
+void /* PRIVATE */
+png_push_process_row(png_structp png_ptr)
+{
+   png_ptr->row_info.color_type = png_ptr->color_type;
+   png_ptr->row_info.width = png_ptr->iwidth;
+   png_ptr->row_info.channels = png_ptr->channels;
+   png_ptr->row_info.bit_depth = png_ptr->bit_depth;
+   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
+
+   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+       png_ptr->row_info.width);
+
+   png_read_filter_row(png_ptr, &(png_ptr->row_info),
+      png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+      (int)(png_ptr->row_buf[0]));
+
+   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
+
+   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
+      png_do_read_transformations(png_ptr);
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   /* Blow up interlaced rows to full size */
+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
+   {
+      if (png_ptr->pass < 6)
+/*       old interface (pre-1.0.9):
+         png_do_read_interlace(&(png_ptr->row_info),
+            png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+ */
+         png_do_read_interlace(png_ptr);
+
+    switch (png_ptr->pass)
+    {
+         case 0:
+         {
+            int i;
+            for (i = 0; i < 8 && png_ptr->pass == 0; i++)
+            {
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+               png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
+            }
+
+            if (png_ptr->pass == 2) /* Pass 1 might be empty */
+            {
+               for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+               {
+                  png_push_have_row(png_ptr, NULL);
+                  png_read_push_finish_row(png_ptr);
+               }
+            }
+
+            if (png_ptr->pass == 4 && png_ptr->height <= 4)
+            {
+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+               {
+                  png_push_have_row(png_ptr, NULL);
+                  png_read_push_finish_row(png_ptr);
+               }
+            }
+
+            if (png_ptr->pass == 6 && png_ptr->height <= 4)
+            {
+                png_push_have_row(png_ptr, NULL);
+                png_read_push_finish_row(png_ptr);
+            }
+
+            break;
+         }
+
+         case 1:
+         {
+            int i;
+            for (i = 0; i < 8 && png_ptr->pass == 1; i++)
+            {
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            if (png_ptr->pass == 2) /* Skip top 4 generated rows */
+            {
+               for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+               {
+                  png_push_have_row(png_ptr, NULL);
+                  png_read_push_finish_row(png_ptr);
+               }
+            }
+
+            break;
+         }
+
+         case 2:
+         {
+            int i;
+
+            for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+            {
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            for (i = 0; i < 4 && png_ptr->pass == 2; i++)
+            {
+               png_push_have_row(png_ptr, NULL);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            if (png_ptr->pass == 4) /* Pass 3 might be empty */
+            {
+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+               {
+                  png_push_have_row(png_ptr, NULL);
+                  png_read_push_finish_row(png_ptr);
+               }
+            }
+
+            break;
+         }
+
+         case 3:
+         {
+            int i;
+
+            for (i = 0; i < 4 && png_ptr->pass == 3; i++)
+            {
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            if (png_ptr->pass == 4) /* Skip top two generated rows */
+            {
+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+               {
+                  png_push_have_row(png_ptr, NULL);
+                  png_read_push_finish_row(png_ptr);
+               }
+            }
+
+            break;
+         }
+
+         case 4:
+         {
+            int i;
+
+            for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+            {
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            for (i = 0; i < 2 && png_ptr->pass == 4; i++)
+            {
+               png_push_have_row(png_ptr, NULL);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            if (png_ptr->pass == 6) /* Pass 5 might be empty */
+            {
+               png_push_have_row(png_ptr, NULL);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            break;
+         }
+
+         case 5:
+         {
+            int i;
+
+            for (i = 0; i < 2 && png_ptr->pass == 5; i++)
+            {
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            if (png_ptr->pass == 6) /* Skip top generated row */
+            {
+               png_push_have_row(png_ptr, NULL);
+               png_read_push_finish_row(png_ptr);
+            }
+
+            break;
+         }
+         case 6:
+         {
+            png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+            png_read_push_finish_row(png_ptr);
+
+            if (png_ptr->pass != 6)
+               break;
+
+            png_push_have_row(png_ptr, NULL);
+            png_read_push_finish_row(png_ptr);
+         }
+      }
+   }
+   else
+#endif
+   {
+      png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+      png_read_push_finish_row(png_ptr);
+   }
+}
+
+void /* PRIVATE */
+png_read_push_finish_row(png_structp png_ptr)
+{
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+
+   /* Start of interlace block in the y direction */
+   PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+
+   /* Offset to next interlace block in the y direction */
+   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
+    * it, uncomment it here and in png.h
+   PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+   */
+
+   png_ptr->row_number++;
+   if (png_ptr->row_number < png_ptr->num_rows)
+      return;
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   if (png_ptr->interlaced)
+   {
+      png_ptr->row_number = 0;
+      png_memset(png_ptr->prev_row, 0,
+         png_ptr->rowbytes + 1);
+      do
+      {
+         png_ptr->pass++;
+         if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
+             (png_ptr->pass == 3 && png_ptr->width < 3) ||
+             (png_ptr->pass == 5 && png_ptr->width < 2))
+           png_ptr->pass++;
+
+         if (png_ptr->pass > 7)
+            png_ptr->pass--;
+
+         if (png_ptr->pass >= 7)
+            break;
+
+         png_ptr->iwidth = (png_ptr->width +
+            png_pass_inc[png_ptr->pass] - 1 -
+            png_pass_start[png_ptr->pass]) /
+            png_pass_inc[png_ptr->pass];
+
+         png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
+            png_ptr->iwidth) + 1;
+
+         if (png_ptr->transformations & PNG_INTERLACE)
+            break;
+
+         png_ptr->num_rows = (png_ptr->height +
+            png_pass_yinc[png_ptr->pass] - 1 -
+            png_pass_ystart[png_ptr->pass]) /
+            png_pass_yinc[png_ptr->pass];
+
+      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
+   }
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+}
+
+#ifdef PNG_READ_tEXt_SUPPORTED
+void /* PRIVATE */
+png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+   length)
+{
+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+      {
+         png_error(png_ptr, "Out of place tEXt");
+         info_ptr = info_ptr; /* To quiet some compiler warnings */
+      }
+
+#ifdef PNG_MAX_MALLOC_64K
+   png_ptr->skip_length = 0;  /* This may not be necessary */
+
+   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
+   {
+      png_warning(png_ptr, "tEXt chunk too large to fit in memory");
+      png_ptr->skip_length = length - (png_uint_32)65535L;
+      length = (png_uint_32)65535L;
+   }
+#endif
+
+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+      (png_size_t)(length + 1));
+   png_ptr->current_text[length] = '\0';
+   png_ptr->current_text_ptr = png_ptr->current_text;
+   png_ptr->current_text_size = (png_size_t)length;
+   png_ptr->current_text_left = (png_size_t)length;
+   png_ptr->process_mode = PNG_READ_tEXt_MODE;
+}
+
+void /* PRIVATE */
+png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr->buffer_size && png_ptr->current_text_left)
+   {
+      png_size_t text_size;
+
+      if (png_ptr->buffer_size < png_ptr->current_text_left)
+         text_size = png_ptr->buffer_size;
+
+      else
+         text_size = png_ptr->current_text_left;
+
+      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_ptr += text_size;
+   }
+   if (!(png_ptr->current_text_left))
+   {
+      png_textp text_ptr;
+      png_charp text;
+      png_charp key;
+      int ret;
+
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_crc_finish(png_ptr);
+
+#ifdef PNG_MAX_MALLOC_64K
+      if (png_ptr->skip_length)
+         return;
+#endif
+
+      key = png_ptr->current_text;
+
+      for (text = key; *text; text++)
+         /* Empty loop */ ;
+
+      if (text < key + png_ptr->current_text_size)
+         text++;
+
+      text_ptr = (png_textp)png_malloc(png_ptr,
+         png_sizeof(png_text));
+      text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
+      text_ptr->key = key;
+#ifdef PNG_iTXt_SUPPORTED
+      text_ptr->lang = NULL;
+      text_ptr->lang_key = NULL;
+#endif
+      text_ptr->text = text;
+
+      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+      png_free(png_ptr, key);
+      png_free(png_ptr, text_ptr);
+      png_ptr->current_text = NULL;
+
+      if (ret)
+        png_warning(png_ptr, "Insufficient memory to store text chunk");
+   }
+}
+#endif
+
+#ifdef PNG_READ_zTXt_SUPPORTED
+void /* PRIVATE */
+png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+   length)
+{
+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+      {
+         png_error(png_ptr, "Out of place zTXt");
+         info_ptr = info_ptr; /* To quiet some compiler warnings */
+      }
+
+#ifdef PNG_MAX_MALLOC_64K
+   /* We can't handle zTXt chunks > 64K, since we don't have enough space
+    * to be able to store the uncompressed data.  Actually, the threshold
+    * is probably around 32K, but it isn't as definite as 64K is.
+    */
+   if (length > (png_uint_32)65535L)
+   {
+      png_warning(png_ptr, "zTXt chunk too large to fit in memory");
+      png_push_crc_skip(png_ptr, length);
+      return;
+   }
+#endif
+
+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+      (png_size_t)(length + 1));
+   png_ptr->current_text[length] = '\0';
+   png_ptr->current_text_ptr = png_ptr->current_text;
+   png_ptr->current_text_size = (png_size_t)length;
+   png_ptr->current_text_left = (png_size_t)length;
+   png_ptr->process_mode = PNG_READ_zTXt_MODE;
+}
+
+void /* PRIVATE */
+png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr->buffer_size && png_ptr->current_text_left)
+   {
+      png_size_t text_size;
+
+      if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
+         text_size = png_ptr->buffer_size;
+
+      else
+         text_size = png_ptr->current_text_left;
+
+      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_ptr += text_size;
+   }
+   if (!(png_ptr->current_text_left))
+   {
+      png_textp text_ptr;
+      png_charp text;
+      png_charp key;
+      int ret;
+      png_size_t text_size, key_size;
+
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_crc_finish(png_ptr);
+
+      key = png_ptr->current_text;
+
+      for (text = key; *text; text++)
+         /* Empty loop */ ;
+
+      /* zTXt can't have zero text */
+      if (text >= key + png_ptr->current_text_size)
+      {
+         png_ptr->current_text = NULL;
+         png_free(png_ptr, key);
+         return;
+      }
+
+      text++;
+
+      if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */
+      {
+         png_ptr->current_text = NULL;
+         png_free(png_ptr, key);
+         return;
+      }
+
+      text++;
+
+      png_ptr->zstream.next_in = (png_bytep )text;
+      png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
+         (text - key));
+      png_ptr->zstream.next_out = png_ptr->zbuf;
+      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+      key_size = text - key;
+      text_size = 0;
+      text = NULL;
+      ret = Z_STREAM_END;
+
+      while (png_ptr->zstream.avail_in)
+      {
+         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+         if (ret != Z_OK && ret != Z_STREAM_END)
+         {
+            inflateReset(&png_ptr->zstream);
+            png_ptr->zstream.avail_in = 0;
+            png_ptr->current_text = NULL;
+            png_free(png_ptr, key);
+            png_free(png_ptr, text);
+            return;
+         }
+         if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
+         {
+            if (text == NULL)
+            {
+               text = (png_charp)png_malloc(png_ptr,
+                     (png_ptr->zbuf_size
+                     - png_ptr->zstream.avail_out + key_size + 1));
+
+               png_memcpy(text + key_size, png_ptr->zbuf,
+                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+
+               png_memcpy(text, key, key_size);
+
+               text_size = key_size + png_ptr->zbuf_size -
+                  png_ptr->zstream.avail_out;
+
+               *(text + text_size) = '\0';
+            }
+            else
+            {
+               png_charp tmp;
+
+               tmp = text;
+               text = (png_charp)png_malloc(png_ptr, text_size +
+                  (png_ptr->zbuf_size 
+                  - png_ptr->zstream.avail_out + 1));
+
+               png_memcpy(text, tmp, text_size);
+               png_free(png_ptr, tmp);
+
+               png_memcpy(text + text_size, png_ptr->zbuf,
+                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+
+               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+               *(text + text_size) = '\0';
+            }
+            if (ret != Z_STREAM_END)
+            {
+               png_ptr->zstream.next_out = png_ptr->zbuf;
+               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+            }
+         }
+         else
+         {
+            break;
+         }
+
+         if (ret == Z_STREAM_END)
+            break;
+      }
+
+      inflateReset(&png_ptr->zstream);
+      png_ptr->zstream.avail_in = 0;
+
+      if (ret != Z_STREAM_END)
+      {
+         png_ptr->current_text = NULL;
+         png_free(png_ptr, key);
+         png_free(png_ptr, text);
+         return;
+      }
+
+      png_ptr->current_text = NULL;
+      png_free(png_ptr, key);
+      key = text;
+      text += key_size;
+
+      text_ptr = (png_textp)png_malloc(png_ptr,
+          png_sizeof(png_text));
+      text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
+      text_ptr->key = key;
+#ifdef PNG_iTXt_SUPPORTED
+      text_ptr->lang = NULL;
+      text_ptr->lang_key = NULL;
+#endif
+      text_ptr->text = text;
+
+      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+      png_free(png_ptr, key);
+      png_free(png_ptr, text_ptr);
+
+      if (ret)
+        png_warning(png_ptr, "Insufficient memory to store text chunk");
+   }
+}
+#endif
+
+#ifdef PNG_READ_iTXt_SUPPORTED
+void /* PRIVATE */
+png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+   length)
+{
+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+      {
+         png_error(png_ptr, "Out of place iTXt");
+         info_ptr = info_ptr; /* To quiet some compiler warnings */
+      }
+
+#ifdef PNG_MAX_MALLOC_64K
+   png_ptr->skip_length = 0;  /* This may not be necessary */
+
+   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
+   {
+      png_warning(png_ptr, "iTXt chunk too large to fit in memory");
+      png_ptr->skip_length = length - (png_uint_32)65535L;
+      length = (png_uint_32)65535L;
+   }
+#endif
+
+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+      (png_size_t)(length + 1));
+   png_ptr->current_text[length] = '\0';
+   png_ptr->current_text_ptr = png_ptr->current_text;
+   png_ptr->current_text_size = (png_size_t)length;
+   png_ptr->current_text_left = (png_size_t)length;
+   png_ptr->process_mode = PNG_READ_iTXt_MODE;
+}
+
+void /* PRIVATE */
+png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
+{
+
+   if (png_ptr->buffer_size && png_ptr->current_text_left)
+   {
+      png_size_t text_size;
+
+      if (png_ptr->buffer_size < png_ptr->current_text_left)
+         text_size = png_ptr->buffer_size;
+
+      else
+         text_size = png_ptr->current_text_left;
+
+      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_ptr += text_size;
+   }
+   if (!(png_ptr->current_text_left))
+   {
+      png_textp text_ptr;
+      png_charp key;
+      int comp_flag;
+      png_charp lang;
+      png_charp lang_key;
+      png_charp text;
+      int ret;
+
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_crc_finish(png_ptr);
+
+#ifdef PNG_MAX_MALLOC_64K
+      if (png_ptr->skip_length)
+         return;
+#endif
+
+      key = png_ptr->current_text;
+
+      for (lang = key; *lang; lang++)
+         /* Empty loop */ ;
+
+      if (lang < key + png_ptr->current_text_size - 3)
+         lang++;
+
+      comp_flag = *lang++;
+      lang++;     /* Skip comp_type, always zero */
+
+      for (lang_key = lang; *lang_key; lang_key++)
+         /* Empty loop */ ;
+
+      lang_key++;        /* Skip NUL separator */
+
+      text=lang_key;
+
+      if (lang_key < key + png_ptr->current_text_size - 1)
+      {
+        for (; *text; text++)
+           /* Empty loop */ ;
+      }
+
+      if (text < key + png_ptr->current_text_size)
+         text++;
+
+      text_ptr = (png_textp)png_malloc(png_ptr,
+         png_sizeof(png_text));
+
+      text_ptr->compression = comp_flag + 2;
+      text_ptr->key = key;
+      text_ptr->lang = lang;
+      text_ptr->lang_key = lang_key;
+      text_ptr->text = text;
+      text_ptr->text_length = 0;
+      text_ptr->itxt_length = png_strlen(text);
+
+      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+      png_ptr->current_text = NULL;
+
+      png_free(png_ptr, text_ptr);
+      if (ret)
+         png_warning(png_ptr, "Insufficient memory to store iTXt chunk");
+   }
+}
+#endif
+
+/* This function is called when we haven't found a handler for this
+ * chunk.  If there isn't a problem with the chunk itself (ie a bad chunk
+ * name or a critical chunk), the chunk is (currently) silently ignored.
+ */
+void /* PRIVATE */
+png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
+   length)
+{
+   png_uint_32 skip = 0;
+
+   if (!(png_ptr->chunk_name[0] & 0x20))
+   {
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+      if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+         PNG_HANDLE_CHUNK_ALWAYS
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+         && png_ptr->read_user_chunk_fn == NULL
+#endif
+         )
+#endif
+         png_chunk_error(png_ptr, "unknown critical chunk");
+
+      info_ptr = info_ptr; /* To quiet some compiler warnings */
+   }
+
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+   if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
+   {
+#ifdef PNG_MAX_MALLOC_64K
+      if (length > (png_uint_32)65535L)
+      {
+          png_warning(png_ptr, "unknown chunk too large to fit in memory");
+          skip = length - (png_uint_32)65535L;
+          length = (png_uint_32)65535L;
+      }
+#endif
+      png_memcpy((png_charp)png_ptr->unknown_chunk.name,
+                 (png_charp)png_ptr->chunk_name, 
+                 png_sizeof(png_ptr->unknown_chunk.name));
+      png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]
+        = '\0';
+
+      png_ptr->unknown_chunk.size = (png_size_t)length;
+
+      if (length == 0)
+         png_ptr->unknown_chunk.data = NULL;
+
+      else
+      {
+         png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
+            (png_size_t)length);
+         png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
+      }
+
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+      if (png_ptr->read_user_chunk_fn != NULL)
+      {
+         /* Callback to user unknown chunk handler */
+         int ret;
+         ret = (*(png_ptr->read_user_chunk_fn))
+           (png_ptr, &png_ptr->unknown_chunk);
+
+         if (ret < 0)
+            png_chunk_error(png_ptr, "error in user chunk");
+
+         if (ret == 0)
+         {
+            if (!(png_ptr->chunk_name[0] & 0x20))
+               if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+                    PNG_HANDLE_CHUNK_ALWAYS)
+                  png_chunk_error(png_ptr, "unknown critical chunk");
+            png_set_unknown_chunks(png_ptr, info_ptr,
+               &png_ptr->unknown_chunk, 1);
+         }
+      }
+
+      else
+#endif
+        png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
+      png_free(png_ptr, png_ptr->unknown_chunk.data);
+      png_ptr->unknown_chunk.data = NULL;
+   }
+
+   else
+#endif
+      skip=length;
+   png_push_crc_skip(png_ptr, skip);
+}
+
+void /* PRIVATE */
+png_push_have_info(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr->info_fn != NULL)
+      (*(png_ptr->info_fn))(png_ptr, info_ptr);
+}
+
+void /* PRIVATE */
+png_push_have_end(png_structp png_ptr, png_infop info_ptr)
+{
+   if (png_ptr->end_fn != NULL)
+      (*(png_ptr->end_fn))(png_ptr, info_ptr);
+}
+
+void /* PRIVATE */
+png_push_have_row(png_structp png_ptr, png_bytep row)
+{
+   if (png_ptr->row_fn != NULL)
+      (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
+         (int)png_ptr->pass);
+}
+
+void PNGAPI
+png_progressive_combine_row (png_structp png_ptr,
+   png_bytep old_row, png_bytep new_row)
+{
+   PNG_CONST int FARDATA png_pass_dsp_mask[7] =
+      {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
+
+   if (png_ptr == NULL)
+      return;
+
+   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]);
+}
+
+void PNGAPI
+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_end_ptr end_fn)
+{
+   if (png_ptr == NULL)
+      return;
+
+   png_ptr->info_fn = info_fn;
+   png_ptr->row_fn = row_fn;
+   png_ptr->end_fn = end_fn;
+
+   png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
+}
+
+png_voidp PNGAPI
+png_get_progressive_ptr(png_structp png_ptr)
+{
+   if (png_ptr == NULL)
+      return (NULL);
+
+   return png_ptr->io_ptr;
+}
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
diff --git a/src/libpng/pngread.c b/src/libpng/pngread.c
index 4cb5373b9..1b3a3f575 100644
--- a/src/libpng/pngread.c
+++ b/src/libpng/pngread.c
@@ -1,1509 +1,1349 @@
-

-/* pngread.c - read a PNG file

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This file contains routines that an application calls directly to

- * read a PNG file or stream.

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_READ_SUPPORTED

-

-

-/* Create a PNG structure for reading, and allocate any memory needed. */

-png_structp PNGAPI

-png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)

-{

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,

-      warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));

-}

-

-/* Alternate create PNG structure for reading, and allocate any memory needed. */

-png_structp PNGAPI

-png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)

-{

-#endif /* PNG_USER_MEM_SUPPORTED */

-

-#ifdef PNG_SETJMP_SUPPORTED

-   volatile

-#endif

-   png_structp png_ptr;

-

-#ifdef PNG_SETJMP_SUPPORTED

-#ifdef USE_FAR_KEYWORD

-   jmp_buf jmpbuf;

-#endif

-#endif

-

-   int i;

-

-   png_debug(1, "in png_create_read_struct");

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

-      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);

-#else

-   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

-#endif

-   if (png_ptr == NULL)

-      return (NULL);

-

-   /* Added at libpng-1.2.6 */

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

-   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-#ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

-#else

-   if (setjmp(png_ptr->jmpbuf))

-#endif

-   {

-      png_free(png_ptr, png_ptr->zbuf);

-      png_ptr->zbuf = NULL;

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)png_ptr,

-         (png_free_ptr)free_fn, (png_voidp)mem_ptr);

-#else

-      png_destroy_struct((png_voidp)png_ptr);

-#endif

-      return (NULL);

-   }

-#ifdef USE_FAR_KEYWORD

-   png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));

-#endif

-#endif /* PNG_SETJMP_SUPPORTED */

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

-#endif

-

-   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

-

-   if (user_png_ver)

-   {

-      i = 0;

-      do

-      {

-         if (user_png_ver[i] != png_libpng_ver[i])

-            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

-      } while (png_libpng_ver[i++]);

-    }

-    else

-         png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

-

-

-    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)

-    {

-       /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so

-       * we must recompile any applications that use any older library version.

-       * For versions after libpng 1.0, we will be compatible, so we need

-       * only check the first digit.

-       */

-      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||

-          (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||

-          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))

-      {

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-         char msg[80];

-         if (user_png_ver)

-         {

-           png_snprintf(msg, 80,

-              "Application was compiled with png.h from libpng-%.20s",

-              user_png_ver);

-           png_warning(png_ptr, msg);

-         }

-         png_snprintf(msg, 80,

-             "Application  is  running with png.c from libpng-%.20s",

-             png_libpng_ver);

-         png_warning(png_ptr, msg);

-#endif

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-         png_ptr->flags = 0;

-#endif

-         png_error(png_ptr,

-            "Incompatible libpng version in application and library");

-      }

-   }

-

-   /* Initialize zbuf - compression buffer */

-   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

-   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

-     (png_uint_32)png_ptr->zbuf_size);

-   png_ptr->zstream.zalloc = png_zalloc;

-   png_ptr->zstream.zfree = png_zfree;

-   png_ptr->zstream.opaque = (voidpf)png_ptr;

-

-      switch (inflateInit(&png_ptr->zstream))

-      {

-         case Z_OK: /* Do nothing */ break;

-         case Z_MEM_ERROR:

-         case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error");

-            break;

-         case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error");

-            break;

-         default: png_error(png_ptr, "Unknown zlib error");

-      }

-

-

-   png_ptr->zstream.next_out = png_ptr->zbuf;

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-

-   png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

-

-#ifdef PNG_SETJMP_SUPPORTED

-/* Applications that neglect to set up their own setjmp() and then

-   encounter a png_error() will longjmp here.  Since the jmpbuf is

-   then meaningless we abort instead of returning. */

-#ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

-       PNG_ABORT();

-   png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));

-#else

-   if (setjmp(png_ptr->jmpbuf))

-       PNG_ABORT();

-#endif

-#endif /* PNG_SETJMP_SUPPORTED */

-

-   return (png_ptr);

-}

-

-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

-/* Initialize PNG structure for reading, and allocate any memory needed.

- * This interface is deprecated in favour of the png_create_read_struct(),

- * and it will disappear as of libpng-1.3.0.

- */

-#undef png_read_init

-void PNGAPI

-png_read_init(png_structp png_ptr)

-{

-   /* We only come here via pre-1.0.7-compiled applications */

-   png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);

-}

-

-void PNGAPI

-png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,

-   png_size_t png_struct_size, png_size_t png_info_size)

-{

-   /* We only come here via pre-1.0.12-compiled applications */

-   if (png_ptr == NULL)

-      return;

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-   if (png_sizeof(png_struct) > png_struct_size ||

-      png_sizeof(png_info) > png_info_size)

-   {

-      char msg[80];

-      png_ptr->warning_fn = NULL;

-      if (user_png_ver)

-      {

-        png_snprintf(msg, 80,

-           "Application was compiled with png.h from libpng-%.20s",

-           user_png_ver);

-        png_warning(png_ptr, msg);

-      }

-      png_snprintf(msg, 80,

-         "Application  is  running with png.c from libpng-%.20s",

-         png_libpng_ver);

-      png_warning(png_ptr, msg);

-   }

-#endif

-   if (png_sizeof(png_struct) > png_struct_size)

-   {

-      png_ptr->error_fn = NULL;

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-      png_ptr->flags = 0;

-#endif

-      png_error(png_ptr,

-      "The png struct allocated by the application for reading is too small.");

-   }

-   if (png_sizeof(png_info) > png_info_size)

-   {

-      png_ptr->error_fn = NULL;

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-      png_ptr->flags = 0;

-#endif

-      png_error(png_ptr,

-        "The info struct allocated by application for reading is too small.");

-   }

-   png_read_init_3(&png_ptr, user_png_ver, png_struct_size);

-}

-#endif /* PNG_1_0_X || PNG_1_2_X */

-

-void PNGAPI

-png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,

-   png_size_t png_struct_size)

-{

-#ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf tmp_jmp;  /* to save current jump buffer */

-#endif

-

-   int i = 0;

-

-   png_structp png_ptr=*ptr_ptr;

-

-   if (png_ptr == NULL)

-      return;

-

-   do

-   {

-      if (user_png_ver[i] != png_libpng_ver[i])

-      {

-#ifdef PNG_LEGACY_SUPPORTED

-        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

-#else

-        png_ptr->warning_fn = NULL;

-        png_warning(png_ptr,

-         "Application uses deprecated png_read_init() and should be recompiled.");

-        break;

-#endif

-      }

-   } while (png_libpng_ver[i++]);

-

-   png_debug(1, "in png_read_init_3");

-

-#ifdef PNG_SETJMP_SUPPORTED

-   /* Save jump buffer and error functions */

-   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

-#endif

-

-   if (png_sizeof(png_struct) > png_struct_size)

-   {

-      png_destroy_struct(png_ptr);

-      *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

-      png_ptr = *ptr_ptr;

-   }

-

-   /* Reset all variables to 0 */

-   png_memset(png_ptr, 0, png_sizeof(png_struct));

-

-#ifdef PNG_SETJMP_SUPPORTED

-   /* Restore jump buffer */

-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

-#endif

-

-   /* Added at libpng-1.2.6 */

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

-   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

-#endif

-

-   /* Initialize zbuf - compression buffer */

-   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

-   png_ptr->zstream.zalloc = png_zalloc;

-   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

-     (png_uint_32)png_ptr->zbuf_size);

-   png_ptr->zstream.zalloc = png_zalloc;

-   png_ptr->zstream.zfree = png_zfree;

-   png_ptr->zstream.opaque = (voidpf)png_ptr;

-

-   switch (inflateInit(&png_ptr->zstream))

-   {

-      case Z_OK: /* Do nothing */ break;

-      case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;

-      case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;

-      default: png_error(png_ptr, "Unknown zlib error");

-   }

-

-   png_ptr->zstream.next_out = png_ptr->zbuf;

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-

-   png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

-}

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read the information before the actual image data.  This has been

- * changed in v0.90 to allow reading a file that already has the magic

- * bytes read from the stream.  You can tell libpng how many bytes have

- * been read from the beginning of the stream (up to the maximum of 8)

- * via png_set_sig_bytes(), and we will only check the remaining bytes

- * here.  The application can then have access to the signature bytes we

- * read if it is determined that this isn't a valid PNG file.

- */

-void PNGAPI

-png_read_info(png_structp png_ptr, png_infop info_ptr)

-{

-   png_debug(1, "in png_read_info");

- 

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

- 

-   /* If we haven't checked all of the PNG signature bytes, do so now. */

-   if (png_ptr->sig_bytes < 8)

-   {

-      png_size_t num_checked = png_ptr->sig_bytes,

-                 num_to_check = 8 - num_checked;

-

-      png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);

-      png_ptr->sig_bytes = 8;

-

-      if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

-      {

-         if (num_checked < 4 &&

-             png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

-            png_error(png_ptr, "Not a PNG file");

-         else

-            png_error(png_ptr, "PNG file corrupted by ASCII conversion");

-      }

-      if (num_checked < 3)

-         png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

-   }

-

-   for (;;)

-   {

-#ifdef PNG_USE_LOCAL_ARRAYS

-      PNG_CONST PNG_IHDR;

-      PNG_CONST PNG_IDAT;

-      PNG_CONST PNG_IEND;

-      PNG_CONST PNG_PLTE;

-#ifdef PNG_READ_bKGD_SUPPORTED

-      PNG_CONST PNG_bKGD;

-#endif

-#ifdef PNG_READ_cHRM_SUPPORTED

-      PNG_CONST PNG_cHRM;

-#endif

-#ifdef PNG_READ_gAMA_SUPPORTED

-      PNG_CONST PNG_gAMA;

-#endif

-#ifdef PNG_READ_hIST_SUPPORTED

-      PNG_CONST PNG_hIST;

-#endif

-#ifdef PNG_READ_iCCP_SUPPORTED

-      PNG_CONST PNG_iCCP;

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-      PNG_CONST PNG_iTXt;

-#endif

-#ifdef PNG_READ_oFFs_SUPPORTED

-      PNG_CONST PNG_oFFs;

-#endif

-#ifdef PNG_READ_pCAL_SUPPORTED

-      PNG_CONST PNG_pCAL;

-#endif

-#ifdef PNG_READ_pHYs_SUPPORTED

-      PNG_CONST PNG_pHYs;

-#endif

-#ifdef PNG_READ_sBIT_SUPPORTED

-      PNG_CONST PNG_sBIT;

-#endif

-#ifdef PNG_READ_sCAL_SUPPORTED

-      PNG_CONST PNG_sCAL;

-#endif

-#ifdef PNG_READ_sPLT_SUPPORTED

-      PNG_CONST PNG_sPLT;

-#endif

-#ifdef PNG_READ_sRGB_SUPPORTED

-      PNG_CONST PNG_sRGB;

-#endif

-#ifdef PNG_READ_tEXt_SUPPORTED

-      PNG_CONST PNG_tEXt;

-#endif

-#ifdef PNG_READ_tIME_SUPPORTED

-      PNG_CONST PNG_tIME;

-#endif

-#ifdef PNG_READ_tRNS_SUPPORTED

-      PNG_CONST PNG_tRNS;

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-      PNG_CONST PNG_zTXt;

-#endif

-#endif /* PNG_USE_LOCAL_ARRAYS */

-      png_uint_32 length = png_read_chunk_header(png_ptr);

-      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;

-

-      /* This should be a binary subdivision search or a hash for

-       * matching the chunk name rather than a linear search.

-       */

-      if (!png_memcmp(chunk_name, png_IDAT, 4))

-        if (png_ptr->mode & PNG_AFTER_IDAT)

-          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

-

-      if (!png_memcmp(chunk_name, png_IHDR, 4))

-         png_handle_IHDR(png_ptr, info_ptr, length);

-      else if (!png_memcmp(chunk_name, png_IEND, 4))

-         png_handle_IEND(png_ptr, info_ptr, length);

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-      else if (png_handle_as_unknown(png_ptr, chunk_name))

-      {

-         if (!png_memcmp(chunk_name, png_IDAT, 4))

-            png_ptr->mode |= PNG_HAVE_IDAT;

-         png_handle_unknown(png_ptr, info_ptr, length);

-         if (!png_memcmp(chunk_name, png_PLTE, 4))

-            png_ptr->mode |= PNG_HAVE_PLTE;

-         else if (!png_memcmp(chunk_name, png_IDAT, 4))

-         {

-            if (!(png_ptr->mode & PNG_HAVE_IHDR))

-               png_error(png_ptr, "Missing IHDR before IDAT");

-            else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

-                     !(png_ptr->mode & PNG_HAVE_PLTE))

-               png_error(png_ptr, "Missing PLTE before IDAT");

-            break;

-         }

-      }

-#endif

-      else if (!png_memcmp(chunk_name, png_PLTE, 4))

-         png_handle_PLTE(png_ptr, info_ptr, length);

-      else if (!png_memcmp(chunk_name, png_IDAT, 4))

-      {

-         if (!(png_ptr->mode & PNG_HAVE_IHDR))

-            png_error(png_ptr, "Missing IHDR before IDAT");

-         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

-                  !(png_ptr->mode & PNG_HAVE_PLTE))

-            png_error(png_ptr, "Missing PLTE before IDAT");

-

-         png_ptr->idat_size = length;

-         png_ptr->mode |= PNG_HAVE_IDAT;

-         break;

-      }

-#ifdef PNG_READ_bKGD_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_bKGD, 4))

-         png_handle_bKGD(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_cHRM_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_cHRM, 4))

-         png_handle_cHRM(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_gAMA_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_gAMA, 4))

-         png_handle_gAMA(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_hIST_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_hIST, 4))

-         png_handle_hIST(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_oFFs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_oFFs, 4))

-         png_handle_oFFs(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_pCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pCAL, 4))

-         png_handle_pCAL(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sCAL, 4))

-         png_handle_sCAL(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_pHYs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pHYs, 4))

-         png_handle_pHYs(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sBIT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sBIT, 4))

-         png_handle_sBIT(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sRGB_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sRGB, 4))

-         png_handle_sRGB(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_iCCP_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iCCP, 4))

-         png_handle_iCCP(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sPLT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sPLT, 4))

-         png_handle_sPLT(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_tEXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tEXt, 4))

-         png_handle_tEXt(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_tIME_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tIME, 4))

-         png_handle_tIME(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_tRNS_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tRNS, 4))

-         png_handle_tRNS(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_zTXt, 4))

-         png_handle_zTXt(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iTXt, 4))

-         png_handle_iTXt(png_ptr, info_ptr, length);

-#endif

-      else

-         png_handle_unknown(png_ptr, info_ptr, length);

-   }

-}

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-

-/* Optional call to update the users info_ptr structure */

-void PNGAPI

-png_read_update_info(png_structp png_ptr, png_infop info_ptr)

-{

-   png_debug(1, "in png_read_update_info");

- 

-   if (png_ptr == NULL)

-      return;

-   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

-      png_read_start_row(png_ptr);

-   else

-      png_warning(png_ptr,

-      "Ignoring extra png_read_update_info() call; row buffer not reallocated");

-   png_read_transform_info(png_ptr, info_ptr);

-}

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Initialize palette, background, etc, after transformations

- * are set, but before any reading takes place.  This allows

- * the user to obtain a gamma-corrected palette, for example.

- * If the user doesn't call this, we will do it ourselves.

- */

-void PNGAPI

-png_start_read_image(png_structp png_ptr)

-{

-   png_debug(1, "in png_start_read_image");

- 

-   if (png_ptr == NULL)

-      return;

-   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

-      png_read_start_row(png_ptr);

-}

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-void PNGAPI

-png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)

-{

-   PNG_CONST PNG_IDAT;

-   PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,

-      0xff};

-   PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

-   int ret;

- 

-   if (png_ptr == NULL)

-      return;

- 

-   png_debug2(1, "in png_read_row (row %lu, pass %d)",

-      png_ptr->row_number, png_ptr->pass);

-

-   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

-      png_read_start_row(png_ptr);

-   if (png_ptr->row_number == 0 && png_ptr->pass == 0)

-   {

-   /* Check for transforms that have been set but were defined out */

-#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)

-   if (png_ptr->transformations & PNG_INVERT_MONO)

-      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");

-#endif

-#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)

-   if (png_ptr->transformations & PNG_FILLER)

-      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");

-#endif

-#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)

-   if (png_ptr->transformations & PNG_PACKSWAP)

-      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");

-#endif

-#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)

-   if (png_ptr->transformations & PNG_PACK)

-      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");

-#endif

-#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)

-   if (png_ptr->transformations & PNG_SHIFT)

-      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");

-#endif

-#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)

-   if (png_ptr->transformations & PNG_BGR)

-      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");

-#endif

-#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)

-   if (png_ptr->transformations & PNG_SWAP_BYTES)

-      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");

-#endif

-   }

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* If interlaced and we do not need a new row, combine row and return */

-   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

-   {

-      switch (png_ptr->pass)

-      {

-         case 0:

-            if (png_ptr->row_number & 0x07)

-            {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 1:

-            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

-            {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 2:

-            if ((png_ptr->row_number & 0x07) != 4)

-            {

-               if (dsp_row != NULL && (png_ptr->row_number & 4))

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 3:

-            if ((png_ptr->row_number & 3) || png_ptr->width < 3)

-            {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 4:

-            if ((png_ptr->row_number & 3) != 2)

-            {

-               if (dsp_row != NULL && (png_ptr->row_number & 2))

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 5:

-            if ((png_ptr->row_number & 1) || png_ptr->width < 2)

-            {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 6:

-            if (!(png_ptr->row_number & 1))

-            {

-               png_read_finish_row(png_ptr);

-               return;

-            }

-            break;

-      }

-   }

-#endif

-

-   if (!(png_ptr->mode & PNG_HAVE_IDAT))

-      png_error(png_ptr, "Invalid attempt to read row data");

-

-   png_ptr->zstream.next_out = png_ptr->row_buf;

-   png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;

-   do

-   {

-      if (!(png_ptr->zstream.avail_in))

-      {

-         while (!png_ptr->idat_size)

-         {

-            png_crc_finish(png_ptr, 0);

-

-            png_ptr->idat_size = png_read_chunk_header(png_ptr);

-            if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-               png_error(png_ptr, "Not enough image data");

-         }

-         png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

-         png_ptr->zstream.next_in = png_ptr->zbuf;

-         if (png_ptr->zbuf_size > png_ptr->idat_size)

-            png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

-         png_crc_read(png_ptr, png_ptr->zbuf,

-            (png_size_t)png_ptr->zstream.avail_in);

-         png_ptr->idat_size -= png_ptr->zstream.avail_in;

-      }

-      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-      if (ret == Z_STREAM_END)

-      {

-         if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||

-            png_ptr->idat_size)

-            png_error(png_ptr, "Extra compressed data");

-         png_ptr->mode |= PNG_AFTER_IDAT;

-         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-         break;

-      }

-      if (ret != Z_OK)

-         png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

-                   "Decompression error");

-

-   } while (png_ptr->zstream.avail_out);

-

-   png_ptr->row_info.color_type = png_ptr->color_type;

-   png_ptr->row_info.width = png_ptr->iwidth;

-   png_ptr->row_info.channels = png_ptr->channels;

-   png_ptr->row_info.bit_depth = png_ptr->bit_depth;

-   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

-   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-       png_ptr->row_info.width);

-

-   if (png_ptr->row_buf[0])

-   png_read_filter_row(png_ptr, &(png_ptr->row_info),

-      png_ptr->row_buf + 1, png_ptr->prev_row + 1,

-      (int)(png_ptr->row_buf[0]));

-

-   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,

-      png_ptr->rowbytes + 1);

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

-      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

-   {

-      /* Intrapixel differencing */

-      png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

-   }

-#endif

-

-

-   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

-      png_do_read_transformations(png_ptr);

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* Blow up interlaced rows to full size */

-   if (png_ptr->interlaced &&

-      (png_ptr->transformations & PNG_INTERLACE))

-   {

-      if (png_ptr->pass < 6)

-         /* Old interface (pre-1.0.9):

-          * png_do_read_interlace(&(png_ptr->row_info),

-          *    png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);

-          */

-         png_do_read_interlace(png_ptr);

-

-      if (dsp_row != NULL)

-         png_combine_row(png_ptr, dsp_row,

-            png_pass_dsp_mask[png_ptr->pass]);

-      if (row != NULL)

-         png_combine_row(png_ptr, row,

-            png_pass_mask[png_ptr->pass]);

-   }

-   else

-#endif

-   {

-      if (row != NULL)

-         png_combine_row(png_ptr, row, 0xff);

-      if (dsp_row != NULL)

-         png_combine_row(png_ptr, dsp_row, 0xff);

-   }

-   png_read_finish_row(png_ptr);

-

-   if (png_ptr->read_row_fn != NULL)

-      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

-}

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read one or more rows of image data.  If the image is interlaced,

- * and png_set_interlace_handling() has been called, the rows need to

- * contain the contents of the rows from the previous pass.  If the

- * image has alpha or transparency, and png_handle_alpha()[*] has been

- * called, the rows contents must be initialized to the contents of the

- * screen.

- *

- * "row" holds the actual image, and pixels are placed in it

- * as they arrive.  If the image is displayed after each pass, it will

- * appear to "sparkle" in.  "display_row" can be used to display a

- * "chunky" progressive image, with finer detail added as it becomes

- * available.  If you do not want this "chunky" display, you may pass

- * NULL for display_row.  If you do not want the sparkle display, and

- * you have not called png_handle_alpha(), you may pass NULL for rows.

- * If you have called png_handle_alpha(), and the image has either an

- * alpha channel or a transparency chunk, you must provide a buffer for

- * rows.  In this case, you do not have to provide a display_row buffer

- * also, but you may.  If the image is not interlaced, or if you have

- * not called png_set_interlace_handling(), the display_row buffer will

- * be ignored, so pass NULL to it.

- *

- * [*] png_handle_alpha() does not exist yet, as of this version of libpng

- */

-

-void PNGAPI

-png_read_rows(png_structp png_ptr, png_bytepp row,

-   png_bytepp display_row, png_uint_32 num_rows)

-{

-   png_uint_32 i;

-   png_bytepp rp;

-   png_bytepp dp;

-

-   png_debug(1, "in png_read_rows");

- 

-   if (png_ptr == NULL)

-      return;

-   rp = row;

-   dp = display_row;

-   if (rp != NULL && dp != NULL)

-      for (i = 0; i < num_rows; i++)

-      {

-         png_bytep rptr = *rp++;

-         png_bytep dptr = *dp++;

-

-         png_read_row(png_ptr, rptr, dptr);

-      }

-   else if (rp != NULL)

-      for (i = 0; i < num_rows; i++)

-      {

-         png_bytep rptr = *rp;

-         png_read_row(png_ptr, rptr, png_bytep_NULL);

-         rp++;

-      }

-   else if (dp != NULL)

-      for (i = 0; i < num_rows; i++)

-      {

-         png_bytep dptr = *dp;

-         png_read_row(png_ptr, png_bytep_NULL, dptr);

-         dp++;

-      }

-}

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read the entire image.  If the image has an alpha channel or a tRNS

- * chunk, and you have called png_handle_alpha()[*], you will need to

- * initialize the image to the current image that PNG will be overlaying.

- * We set the num_rows again here, in case it was incorrectly set in

- * png_read_start_row() by a call to png_read_update_info() or

- * png_start_read_image() if png_set_interlace_handling() wasn't called

- * prior to either of these functions like it should have been.  You can

- * only call this function once.  If you desire to have an image for

- * each pass of a interlaced image, use png_read_rows() instead.

- *

- * [*] png_handle_alpha() does not exist yet, as of this version of libpng

- */

-void PNGAPI

-png_read_image(png_structp png_ptr, png_bytepp image)

-{

-   png_uint_32 i, image_height;

-   int pass, j;

-   png_bytepp rp;

-

-   png_debug(1, "in png_read_image");

- 

-   if (png_ptr == NULL)

-      return;

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   pass = png_set_interlace_handling(png_ptr);

-#else

-   if (png_ptr->interlaced)

-      png_error(png_ptr,

-        "Cannot read interlaced image -- interlace handler disabled.");

-   pass = 1;

-#endif

-

-

-   image_height=png_ptr->height;

-   png_ptr->num_rows = image_height; /* Make sure this is set correctly */

-

-   for (j = 0; j < pass; j++)

-   {

-      rp = image;

-      for (i = 0; i < image_height; i++)

-      {

-         png_read_row(png_ptr, *rp, png_bytep_NULL);

-         rp++;

-      }

-   }

-}

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read the end of the PNG file.  Will not read past the end of the

- * file, will verify the end is accurate, and will read any comments

- * or time information at the end of the file, if info is not NULL.

- */

-void PNGAPI

-png_read_end(png_structp png_ptr, png_infop info_ptr)

-{

-   png_debug(1, "in png_read_end");

- 

-   if (png_ptr == NULL)

-      return;

-   png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */

-

-   do

-   {

-#ifdef PNG_USE_LOCAL_ARRAYS

-      PNG_CONST PNG_IHDR;

-      PNG_CONST PNG_IDAT;

-      PNG_CONST PNG_IEND;

-      PNG_CONST PNG_PLTE;

-#ifdef PNG_READ_bKGD_SUPPORTED

-      PNG_CONST PNG_bKGD;

-#endif

-#ifdef PNG_READ_cHRM_SUPPORTED

-      PNG_CONST PNG_cHRM;

-#endif

-#ifdef PNG_READ_gAMA_SUPPORTED

-      PNG_CONST PNG_gAMA;

-#endif

-#ifdef PNG_READ_hIST_SUPPORTED

-      PNG_CONST PNG_hIST;

-#endif

-#ifdef PNG_READ_iCCP_SUPPORTED

-      PNG_CONST PNG_iCCP;

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-      PNG_CONST PNG_iTXt;

-#endif

-#ifdef PNG_READ_oFFs_SUPPORTED

-      PNG_CONST PNG_oFFs;

-#endif

-#ifdef PNG_READ_pCAL_SUPPORTED

-      PNG_CONST PNG_pCAL;

-#endif

-#ifdef PNG_READ_pHYs_SUPPORTED

-      PNG_CONST PNG_pHYs;

-#endif

-#ifdef PNG_READ_sBIT_SUPPORTED

-      PNG_CONST PNG_sBIT;

-#endif

-#ifdef PNG_READ_sCAL_SUPPORTED

-      PNG_CONST PNG_sCAL;

-#endif

-#ifdef PNG_READ_sPLT_SUPPORTED

-      PNG_CONST PNG_sPLT;

-#endif

-#ifdef PNG_READ_sRGB_SUPPORTED

-      PNG_CONST PNG_sRGB;

-#endif

-#ifdef PNG_READ_tEXt_SUPPORTED

-      PNG_CONST PNG_tEXt;

-#endif

-#ifdef PNG_READ_tIME_SUPPORTED

-      PNG_CONST PNG_tIME;

-#endif

-#ifdef PNG_READ_tRNS_SUPPORTED

-      PNG_CONST PNG_tRNS;

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-      PNG_CONST PNG_zTXt;

-#endif

-#endif /* PNG_USE_LOCAL_ARRAYS */

-      png_uint_32 length = png_read_chunk_header(png_ptr);

-      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;

-

-      if (!png_memcmp(chunk_name, png_IHDR, 4))

-         png_handle_IHDR(png_ptr, info_ptr, length);

-      else if (!png_memcmp(chunk_name, png_IEND, 4))

-         png_handle_IEND(png_ptr, info_ptr, length);

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-      else if (png_handle_as_unknown(png_ptr, chunk_name))

-      {

-         if (!png_memcmp(chunk_name, png_IDAT, 4))

-         {

-            if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

-               png_error(png_ptr, "Too many IDAT's found");

-         }

-         png_handle_unknown(png_ptr, info_ptr, length);

-         if (!png_memcmp(chunk_name, png_PLTE, 4))

-            png_ptr->mode |= PNG_HAVE_PLTE;

-      }

-#endif

-      else if (!png_memcmp(chunk_name, png_IDAT, 4))

-      {

-         /* Zero length IDATs are legal after the last IDAT has been

-          * read, but not after other chunks have been read.

-          */

-         if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

-            png_error(png_ptr, "Too many IDAT's found");

-         png_crc_finish(png_ptr, length);

-      }

-      else if (!png_memcmp(chunk_name, png_PLTE, 4))

-         png_handle_PLTE(png_ptr, info_ptr, length);

-#ifdef PNG_READ_bKGD_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_bKGD, 4))

-         png_handle_bKGD(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_cHRM_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_cHRM, 4))

-         png_handle_cHRM(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_gAMA_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_gAMA, 4))

-         png_handle_gAMA(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_hIST_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_hIST, 4))

-         png_handle_hIST(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_oFFs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_oFFs, 4))

-         png_handle_oFFs(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_pCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pCAL, 4))

-         png_handle_pCAL(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sCAL, 4))

-         png_handle_sCAL(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_pHYs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pHYs, 4))

-         png_handle_pHYs(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sBIT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sBIT, 4))

-         png_handle_sBIT(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sRGB_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sRGB, 4))

-         png_handle_sRGB(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_iCCP_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iCCP, 4))

-         png_handle_iCCP(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_sPLT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sPLT, 4))

-         png_handle_sPLT(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_tEXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tEXt, 4))

-         png_handle_tEXt(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_tIME_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tIME, 4))

-         png_handle_tIME(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_tRNS_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tRNS, 4))

-         png_handle_tRNS(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_zTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_zTXt, 4))

-         png_handle_zTXt(png_ptr, info_ptr, length);

-#endif

-#ifdef PNG_READ_iTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iTXt, 4))

-         png_handle_iTXt(png_ptr, info_ptr, length);

-#endif

-      else

-         png_handle_unknown(png_ptr, info_ptr, length);

-   } while (!(png_ptr->mode & PNG_HAVE_IEND));

-}

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-

-/* Free all memory used by the read */

-void PNGAPI

-png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,

-   png_infopp end_info_ptr_ptr)

-{

-   png_structp png_ptr = NULL;

-   png_infop info_ptr = NULL, end_info_ptr = NULL;

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn = NULL;

-   png_voidp mem_ptr = NULL;

-#endif

-

-   png_debug(1, "in png_destroy_read_struct");

- 

-   if (png_ptr_ptr != NULL)

-      png_ptr = *png_ptr_ptr;

-   if (png_ptr == NULL)

-      return;

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   free_fn = png_ptr->free_fn;

-   mem_ptr = png_ptr->mem_ptr;

-#endif

-

-   if (info_ptr_ptr != NULL)

-      info_ptr = *info_ptr_ptr;

-

-   if (end_info_ptr_ptr != NULL)

-      end_info_ptr = *end_info_ptr_ptr;

-

-   png_read_destroy(png_ptr, info_ptr, end_info_ptr);

-

-   if (info_ptr != NULL)

-   {

-#ifdef PNG_TEXT_SUPPORTED

-      png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);

-#endif

-

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

-          (png_voidp)mem_ptr);

-#else

-      png_destroy_struct((png_voidp)info_ptr);

-#endif

-      *info_ptr_ptr = NULL;

-   }

-

-   if (end_info_ptr != NULL)

-   {

-#ifdef PNG_READ_TEXT_SUPPORTED

-      png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);

-#endif

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,

-         (png_voidp)mem_ptr);

-#else

-      png_destroy_struct((png_voidp)end_info_ptr);

-#endif

-      *end_info_ptr_ptr = NULL;

-   }

-

-   if (png_ptr != NULL)

-   {

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,

-          (png_voidp)mem_ptr);

-#else

-      png_destroy_struct((png_voidp)png_ptr);

-#endif

-      *png_ptr_ptr = NULL;

-   }

-}

-

-/* Free all memory used by the read (old method) */

-void /* PRIVATE */

-png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)

-{

-#ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf tmp_jmp;

-#endif

-   png_error_ptr error_fn;

-   png_error_ptr warning_fn;

-   png_voidp error_ptr;

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn;

-#endif

-

-   png_debug(1, "in png_read_destroy");

- 

-   if (info_ptr != NULL)

-      png_info_destroy(png_ptr, info_ptr);

-

-   if (end_info_ptr != NULL)

-      png_info_destroy(png_ptr, end_info_ptr);

-

-   png_free(png_ptr, png_ptr->zbuf);

-   png_free(png_ptr, png_ptr->big_row_buf);

-   png_free(png_ptr, png_ptr->prev_row);

-   png_free(png_ptr, png_ptr->chunkdata);

-#ifdef PNG_READ_DITHER_SUPPORTED

-   png_free(png_ptr, png_ptr->palette_lookup);

-   png_free(png_ptr, png_ptr->dither_index);

-#endif

-#ifdef PNG_READ_GAMMA_SUPPORTED

-   png_free(png_ptr, png_ptr->gamma_table);

-#endif

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   png_free(png_ptr, png_ptr->gamma_from_1);

-   png_free(png_ptr, png_ptr->gamma_to_1);

-#endif

-#ifdef PNG_FREE_ME_SUPPORTED

-   if (png_ptr->free_me & PNG_FREE_PLTE)

-      png_zfree(png_ptr, png_ptr->palette);

-   png_ptr->free_me &= ~PNG_FREE_PLTE;

-#else

-   if (png_ptr->flags & PNG_FLAG_FREE_PLTE)

-      png_zfree(png_ptr, png_ptr->palette);

-   png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;

-#endif

-#if defined(PNG_tRNS_SUPPORTED) || \

-    defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-#ifdef PNG_FREE_ME_SUPPORTED

-   if (png_ptr->free_me & PNG_FREE_TRNS)

-      png_free(png_ptr, png_ptr->trans);

-   png_ptr->free_me &= ~PNG_FREE_TRNS;

-#else

-   if (png_ptr->flags & PNG_FLAG_FREE_TRNS)

-      png_free(png_ptr, png_ptr->trans);

-   png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;

-#endif

-#endif

-#ifdef PNG_READ_hIST_SUPPORTED

-#ifdef PNG_FREE_ME_SUPPORTED

-   if (png_ptr->free_me & PNG_FREE_HIST)

-      png_free(png_ptr, png_ptr->hist);

-   png_ptr->free_me &= ~PNG_FREE_HIST;

-#else

-   if (png_ptr->flags & PNG_FLAG_FREE_HIST)

-      png_free(png_ptr, png_ptr->hist);

-   png_ptr->flags &= ~PNG_FLAG_FREE_HIST;

-#endif

-#endif

-#ifdef PNG_READ_GAMMA_SUPPORTED

-   if (png_ptr->gamma_16_table != NULL)

-   {

-      int i;

-      int istop = (1 << (8 - png_ptr->gamma_shift));

-      for (i = 0; i < istop; i++)

-      {

-         png_free(png_ptr, png_ptr->gamma_16_table[i]);

-      }

-   png_free(png_ptr, png_ptr->gamma_16_table);

-   }

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   if (png_ptr->gamma_16_from_1 != NULL)

-   {

-      int i;

-      int istop = (1 << (8 - png_ptr->gamma_shift));

-      for (i = 0; i < istop; i++)

-      {

-         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);

-      }

-   png_free(png_ptr, png_ptr->gamma_16_from_1);

-   }

-   if (png_ptr->gamma_16_to_1 != NULL)

-   {

-      int i;

-      int istop = (1 << (8 - png_ptr->gamma_shift));

-      for (i = 0; i < istop; i++)

-      {

-         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);

-      }

-   png_free(png_ptr, png_ptr->gamma_16_to_1);

-   }

-#endif

-#endif

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-   png_free(png_ptr, png_ptr->time_buffer);

-#endif

-

-   inflateEnd(&png_ptr->zstream);

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-   png_free(png_ptr, png_ptr->save_buffer);

-#endif

-

-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-#ifdef PNG_TEXT_SUPPORTED

-   png_free(png_ptr, png_ptr->current_text);

-#endif /* PNG_TEXT_SUPPORTED */

-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

-

-   /* Save the important info out of the png_struct, in case it is

-    * being used again.

-    */

-#ifdef PNG_SETJMP_SUPPORTED

-   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

-#endif

-

-   error_fn = png_ptr->error_fn;

-   warning_fn = png_ptr->warning_fn;

-   error_ptr = png_ptr->error_ptr;

-#ifdef PNG_USER_MEM_SUPPORTED

-   free_fn = png_ptr->free_fn;

-#endif

-

-   png_memset(png_ptr, 0, png_sizeof(png_struct));

-

-   png_ptr->error_fn = error_fn;

-   png_ptr->warning_fn = warning_fn;

-   png_ptr->error_ptr = error_ptr;

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr->free_fn = free_fn;

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

-#endif

-

-}

-

-void PNGAPI

-png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)

-{

-   if (png_ptr == NULL)

-      return;

-   png_ptr->read_row_fn = read_row_fn;

-}

-

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-void PNGAPI

-png_read_png(png_structp png_ptr, png_infop info_ptr,

-                           int transforms,

-                           voidp params)

-{

-   int row;

-

-   if (png_ptr == NULL)

-      return;

-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-   /* Invert the alpha channel from opacity to transparency

-    */

-   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

-       png_set_invert_alpha(png_ptr);

-#endif

-

-   /* png_read_info() gives us all of the information from the

-    * PNG file before the first IDAT (image data chunk).

-    */

-   png_read_info(png_ptr, info_ptr);

-   if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))

-      png_error(png_ptr, "Image is too high to process with png_read_png()");

-

-   /* -------------- image transformations start here ------------------- */

-

-#ifdef PNG_READ_16_TO_8_SUPPORTED

-   /* Tell libpng to strip 16 bit/color files down to 8 bits per color.

-    */

-   if (transforms & PNG_TRANSFORM_STRIP_16)

-      png_set_strip_16(png_ptr);

-#endif

-

-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-   /* Strip alpha bytes from the input data without combining with

-    * the background (not recommended).

-    */

-   if (transforms & PNG_TRANSFORM_STRIP_ALPHA)

-      png_set_strip_alpha(png_ptr);

-#endif

-

-#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)

-   /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single

-    * byte into separate bytes (useful for paletted and grayscale images).

-    */

-   if (transforms & PNG_TRANSFORM_PACKING)

-      png_set_packing(png_ptr);

-#endif

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-   /* Change the order of packed pixels to least significant bit first

-    * (not useful if you are using png_set_packing).

-    */

-   if (transforms & PNG_TRANSFORM_PACKSWAP)

-      png_set_packswap(png_ptr);

-#endif

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-   /* Expand paletted colors into true RGB triplets

-    * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel

-    * Expand paletted or RGB images with transparency to full alpha

-    * channels so the data will be available as RGBA quartets.

-    */

-   if (transforms & PNG_TRANSFORM_EXPAND)

-      if ((png_ptr->bit_depth < 8) ||

-          (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||

-          (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))

-         png_set_expand(png_ptr);

-#endif

-

-   /* We don't handle background color or gamma transformation or dithering.

-    */

-

-#ifdef PNG_READ_INVERT_SUPPORTED

-   /* Invert monochrome files to have 0 as white and 1 as black

-    */

-   if (transforms & PNG_TRANSFORM_INVERT_MONO)

-      png_set_invert_mono(png_ptr);

-#endif

-

-#ifdef PNG_READ_SHIFT_SUPPORTED

-   /* If you want to shift the pixel values from the range [0,255] or

-    * [0,65535] to the original [0,7] or [0,31], or whatever range the

-    * colors were originally in:

-    */

-   if ((transforms & PNG_TRANSFORM_SHIFT)

-       && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))

-   {

-      png_color_8p sig_bit;

-

-      png_get_sBIT(png_ptr, info_ptr, &sig_bit);

-      png_set_shift(png_ptr, sig_bit);

-   }

-#endif

-

-#ifdef PNG_READ_BGR_SUPPORTED

-   /* Flip the RGB pixels to BGR (or RGBA to BGRA)

-    */

-   if (transforms & PNG_TRANSFORM_BGR)

-      png_set_bgr(png_ptr);

-#endif

-

-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

-   /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)

-    */

-   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)

-       png_set_swap_alpha(png_ptr);

-#endif

-

-#ifdef PNG_READ_SWAP_SUPPORTED

-   /* Swap bytes of 16 bit files to least significant byte first

-    */

-   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)

-      png_set_swap(png_ptr);

-#endif

-

-/* Added at libpng-1.2.41 */

-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-   /* Invert the alpha channel from opacity to transparency

-    */

-   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

-       png_set_invert_alpha(png_ptr);

-#endif

-

-/* Added at libpng-1.2.41 */

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   /* Expand grayscale image to RGB

-    */

-   if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)

-       png_set_gray_to_rgb(png_ptr);

-#endif

-

-   /* We don't handle adding filler bytes */

-

-   /* Optional call to gamma correct and add the background to the palette

-    * and update info structure.  REQUIRED if you are expecting libpng to

-    * update the palette for you (i.e., you selected such a transform above).

-    */

-   png_read_update_info(png_ptr, info_ptr);

-

-   /* -------------- image transformations end here ------------------- */

-

-#ifdef PNG_FREE_ME_SUPPORTED

-   png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

-#endif

-   if (info_ptr->row_pointers == NULL)

-   {

-      info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,

-         info_ptr->height * png_sizeof(png_bytep));

-      png_memset(info_ptr->row_pointers, 0, info_ptr->height

-         * png_sizeof(png_bytep));

-

-#ifdef PNG_FREE_ME_SUPPORTED

-      info_ptr->free_me |= PNG_FREE_ROWS;

-#endif

-

-      for (row = 0; row < (int)info_ptr->height; row++)

-         info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,

-            png_get_rowbytes(png_ptr, info_ptr));

-   }

-

-   png_read_image(png_ptr, info_ptr->row_pointers);

-   info_ptr->valid |= PNG_INFO_IDAT;

-

-   /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */

-   png_read_end(png_ptr, info_ptr);

-

-   transforms = transforms; /* Quiet compiler warnings */

-   params = params;

-

-}

-#endif /* PNG_INFO_IMAGE_SUPPORTED */

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-#endif /* PNG_READ_SUPPORTED */

+
+/* pngread.c - read a PNG file
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file contains routines that an application calls directly to
+ * read a PNG file or stream.
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_READ_SUPPORTED
+#include "pngpriv.h"
+
+
+/* Create a PNG structure for reading, and allocate any memory needed. */
+png_structp PNGAPI
+png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn)
+{
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
+      warn_fn, NULL, NULL, NULL));
+}
+
+/* Alternate create PNG structure for reading, and allocate any memory needed. */
+png_structp PNGAPI
+png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+#ifdef PNG_SETJMP_SUPPORTED
+   volatile
+#endif
+   png_structp png_ptr;
+   volatile int png_cleanup_needed = 0;
+
+#ifdef PNG_SETJMP_SUPPORTED
+#ifdef USE_FAR_KEYWORD
+   jmp_buf jmpbuf;
+#endif
+#endif
+
+   int i;
+
+   png_debug(1, "in png_create_read_struct");
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+      malloc_fn, mem_ptr);
+#else
+   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+#endif
+   if (png_ptr == NULL)
+      return (NULL);
+
+   /* Added at libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
+   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
+   /* Added at libpng-1.4.0 */
+   png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* Applications that neglect to set up their own setjmp() and then
+   encounter a png_error() will longjmp here.  Since the jmpbuf is
+   then meaningless we abort instead of returning. */
+#ifdef USE_FAR_KEYWORD
+   if (setjmp(jmpbuf))
+#else
+   if (setjmp(png_jmpbuf(png_ptr))) /* Sets longjmp to match setjmp */
+#endif
+      PNG_ABORT();
+#ifdef USE_FAR_KEYWORD
+   png_memcpy(png_jmpbuf(png_ptr), jmpbuf, png_sizeof(jmp_buf));
+#endif
+#endif /* PNG_SETJMP_SUPPORTED */
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+#endif
+
+   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
+
+   if (user_png_ver)
+   {
+      i = 0;
+      do
+      {
+         if (user_png_ver[i] != png_libpng_ver[i])
+            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+      } while (png_libpng_ver[i++]);
+    }
+    else
+         png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+
+
+    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
+    {
+       /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
+       * we must recompile any applications that use any older library version.
+       * For versions after libpng 1.0, we will be compatible, so we need
+       * only check the first digit.
+       */
+      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
+          (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
+          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
+      {
+#ifdef PNG_STDIO_SUPPORTED
+         char msg[80];
+         if (user_png_ver)
+         {
+           png_snprintf(msg, 80,
+              "Application was compiled with png.h from libpng-%.20s",
+              user_png_ver);
+           png_warning(png_ptr, msg);
+         }
+         png_snprintf(msg, 80,
+             "Application  is  running with png.c from libpng-%.20s",
+             png_libpng_ver);
+         png_warning(png_ptr, msg);
+#endif
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+         png_ptr->flags = 0;
+#endif
+         png_warning(png_ptr,
+            "Incompatible libpng version in application and library");
+
+         png_cleanup_needed = 1;
+      }
+   }
+
+   if (!png_cleanup_needed)
+   {
+   /* Initialize zbuf - compression buffer */
+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+   png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr,
+     png_ptr->zbuf_size);
+   if (png_ptr->zbuf == NULL)
+        png_cleanup_needed = 1;
+   }
+   png_ptr->zstream.zalloc = png_zalloc;
+   png_ptr->zstream.zfree = png_zfree;
+   png_ptr->zstream.opaque = (voidpf)png_ptr;
+
+   if (!png_cleanup_needed)
+   {
+      switch (inflateInit(&png_ptr->zstream))
+      {
+         case Z_OK: /* Do nothing */ break;
+         case Z_MEM_ERROR:
+         case Z_STREAM_ERROR: png_warning(png_ptr, "zlib memory error");
+            png_cleanup_needed = 1; break;
+         case Z_VERSION_ERROR: png_warning(png_ptr, "zlib version error");
+            png_cleanup_needed = 1; break;
+         default: png_warning(png_ptr, "Unknown zlib error");
+            png_cleanup_needed = 1;
+      }
+   }
+
+   if (png_cleanup_needed)
+   {
+      /* Clean up PNG structure and deallocate any memory. */
+      png_free(png_ptr, png_ptr->zbuf);
+      png_ptr->zbuf = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)png_ptr,
+         (png_free_ptr)free_fn, (png_voidp)mem_ptr);
+#else
+      png_destroy_struct((png_voidp)png_ptr);
+#endif
+      return (NULL);
+   }
+
+   png_ptr->zstream.next_out = png_ptr->zbuf;
+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+   png_set_read_fn(png_ptr, NULL, NULL);
+
+
+   return (png_ptr);
+}
+
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the information before the actual image data.  This has been
+ * changed in v0.90 to allow reading a file that already has the magic
+ * bytes read from the stream.  You can tell libpng how many bytes have
+ * been read from the beginning of the stream (up to the maximum of 8)
+ * via png_set_sig_bytes(), and we will only check the remaining bytes
+ * here.  The application can then have access to the signature bytes we
+ * read if it is determined that this isn't a valid PNG file.
+ */
+void PNGAPI
+png_read_info(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_read_info");
+ 
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+ 
+   /* If we haven't checked all of the PNG signature bytes, do so now. */
+   if (png_ptr->sig_bytes < 8)
+   {
+      png_size_t num_checked = png_ptr->sig_bytes,
+                 num_to_check = 8 - num_checked;
+
+#ifdef PNG_IO_STATE_SUPPORTED
+      png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;
+#endif
+
+      png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
+      png_ptr->sig_bytes = 8;
+
+      if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
+      {
+         if (num_checked < 4 &&
+             png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
+            png_error(png_ptr, "Not a PNG file");
+         else
+            png_error(png_ptr, "PNG file corrupted by ASCII conversion");
+      }
+      if (num_checked < 3)
+         png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
+   }
+
+   for (;;)
+   {
+      PNG_IHDR;
+      PNG_IDAT;
+      PNG_IEND;
+      PNG_PLTE;
+#ifdef PNG_READ_bKGD_SUPPORTED
+      PNG_bKGD;
+#endif
+#ifdef PNG_READ_cHRM_SUPPORTED
+      PNG_cHRM;
+#endif
+#ifdef PNG_READ_gAMA_SUPPORTED
+      PNG_gAMA;
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+      PNG_hIST;
+#endif
+#ifdef PNG_READ_iCCP_SUPPORTED
+      PNG_iCCP;
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+      PNG_iTXt;
+#endif
+#ifdef PNG_READ_oFFs_SUPPORTED
+      PNG_oFFs;
+#endif
+#ifdef PNG_READ_pCAL_SUPPORTED
+      PNG_pCAL;
+#endif
+#ifdef PNG_READ_pHYs_SUPPORTED
+      PNG_pHYs;
+#endif
+#ifdef PNG_READ_sBIT_SUPPORTED
+      PNG_sBIT;
+#endif
+#ifdef PNG_READ_sCAL_SUPPORTED
+      PNG_sCAL;
+#endif
+#ifdef PNG_READ_sPLT_SUPPORTED
+      PNG_sPLT;
+#endif
+#ifdef PNG_READ_sRGB_SUPPORTED
+      PNG_sRGB;
+#endif
+#ifdef PNG_READ_tEXt_SUPPORTED
+      PNG_tEXt;
+#endif
+#ifdef PNG_READ_tIME_SUPPORTED
+      PNG_tIME;
+#endif
+#ifdef PNG_READ_tRNS_SUPPORTED
+      PNG_tRNS;
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+      PNG_zTXt;
+#endif
+      png_uint_32 length = png_read_chunk_header(png_ptr);
+      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
+
+      /* This should be a binary subdivision search or a hash for
+       * matching the chunk name rather than a linear search.
+       */
+      if (!png_memcmp(chunk_name, png_IDAT, 4))
+        if (png_ptr->mode & PNG_AFTER_IDAT)
+          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
+
+      if (!png_memcmp(chunk_name, png_IHDR, 4))
+         png_handle_IHDR(png_ptr, info_ptr, length);
+      else if (!png_memcmp(chunk_name, png_IEND, 4))
+         png_handle_IEND(png_ptr, info_ptr, length);
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+      else if (png_handle_as_unknown(png_ptr, chunk_name))
+      {
+         if (!png_memcmp(chunk_name, png_IDAT, 4))
+            png_ptr->mode |= PNG_HAVE_IDAT;
+         png_handle_unknown(png_ptr, info_ptr, length);
+         if (!png_memcmp(chunk_name, png_PLTE, 4))
+            png_ptr->mode |= PNG_HAVE_PLTE;
+         else if (!png_memcmp(chunk_name, png_IDAT, 4))
+         {
+            if (!(png_ptr->mode & PNG_HAVE_IHDR))
+               png_error(png_ptr, "Missing IHDR before IDAT");
+            else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+                     !(png_ptr->mode & PNG_HAVE_PLTE))
+               png_error(png_ptr, "Missing PLTE before IDAT");
+            break;
+         }
+      }
+#endif
+      else if (!png_memcmp(chunk_name, png_PLTE, 4))
+         png_handle_PLTE(png_ptr, info_ptr, length);
+      else if (!png_memcmp(chunk_name, png_IDAT, 4))
+      {
+         if (!(png_ptr->mode & PNG_HAVE_IHDR))
+            png_error(png_ptr, "Missing IHDR before IDAT");
+         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+                  !(png_ptr->mode & PNG_HAVE_PLTE))
+            png_error(png_ptr, "Missing PLTE before IDAT");
+
+         png_ptr->idat_size = length;
+         png_ptr->mode |= PNG_HAVE_IDAT;
+         break;
+      }
+#ifdef PNG_READ_bKGD_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_bKGD, 4))
+         png_handle_bKGD(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_cHRM_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_cHRM, 4))
+         png_handle_cHRM(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_gAMA_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_gAMA, 4))
+         png_handle_gAMA(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_hIST, 4))
+         png_handle_hIST(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_oFFs_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_oFFs, 4))
+         png_handle_oFFs(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_pCAL_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_pCAL, 4))
+         png_handle_pCAL(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sCAL_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sCAL, 4))
+         png_handle_sCAL(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_pHYs_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_pHYs, 4))
+         png_handle_pHYs(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sBIT_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sBIT, 4))
+         png_handle_sBIT(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sRGB_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sRGB, 4))
+         png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_iCCP_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_iCCP, 4))
+         png_handle_iCCP(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sPLT_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sPLT, 4))
+         png_handle_sPLT(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_tEXt_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_tEXt, 4))
+         png_handle_tEXt(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_tIME_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_tIME, 4))
+         png_handle_tIME(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_tRNS_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_tRNS, 4))
+         png_handle_tRNS(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_zTXt, 4))
+         png_handle_zTXt(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_iTXt, 4))
+         png_handle_iTXt(png_ptr, info_ptr, length);
+#endif
+      else
+         png_handle_unknown(png_ptr, info_ptr, length);
+   }
+}
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+
+/* Optional call to update the users info_ptr structure */
+void PNGAPI
+png_read_update_info(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_read_update_info");
+ 
+   if (png_ptr == NULL)
+      return;
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+      png_read_start_row(png_ptr);
+   else
+      png_warning(png_ptr,
+      "Ignoring extra png_read_update_info() call; row buffer not reallocated");
+
+   png_read_transform_info(png_ptr, info_ptr);
+}
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Initialize palette, background, etc, after transformations
+ * are set, but before any reading takes place.  This allows
+ * the user to obtain a gamma-corrected palette, for example.
+ * If the user doesn't call this, we will do it ourselves.
+ */
+void PNGAPI
+png_start_read_image(png_structp png_ptr)
+{
+   png_debug(1, "in png_start_read_image");
+ 
+   if (png_ptr == NULL)
+      return;
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+      png_read_start_row(png_ptr);
+}
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+void PNGAPI
+png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
+{
+   PNG_IDAT;
+   PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
+      0xff};
+   PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
+   int ret;
+ 
+   if (png_ptr == NULL)
+      return;
+ 
+   png_debug2(1, "in png_read_row (row %lu, pass %d)",
+      (unsigned long) png_ptr->row_number, png_ptr->pass);
+
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+      png_read_start_row(png_ptr);
+   if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+   {
+   /* Check for transforms that have been set but were defined out */
+#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
+#endif
+#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
+   if (png_ptr->transformations & PNG_FILLER)
+      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
+#endif
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
+#endif
+#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
+   if (png_ptr->transformations & PNG_PACK)
+      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
+#endif
+#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
+#endif
+#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
+   if (png_ptr->transformations & PNG_BGR)
+      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
+#endif
+#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
+#endif
+   }
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   /* If interlaced and we do not need a new row, combine row and return */
+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
+   {
+      switch (png_ptr->pass)
+      {
+         case 0:
+            if (png_ptr->row_number & 0x07)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 1:
+            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 2:
+            if ((png_ptr->row_number & 0x07) != 4)
+            {
+               if (dsp_row != NULL && (png_ptr->row_number & 4))
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 3:
+            if ((png_ptr->row_number & 3) || png_ptr->width < 3)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 4:
+            if ((png_ptr->row_number & 3) != 2)
+            {
+               if (dsp_row != NULL && (png_ptr->row_number & 2))
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 5:
+            if ((png_ptr->row_number & 1) || png_ptr->width < 2)
+            {
+               if (dsp_row != NULL)
+                  png_combine_row(png_ptr, dsp_row,
+                     png_pass_dsp_mask[png_ptr->pass]);
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 6:
+            if (!(png_ptr->row_number & 1))
+            {
+               png_read_finish_row(png_ptr);
+               return;
+            }
+            break;
+      }
+   }
+#endif
+
+   if (!(png_ptr->mode & PNG_HAVE_IDAT))
+      png_error(png_ptr, "Invalid attempt to read row data");
+
+   png_ptr->zstream.next_out = png_ptr->row_buf;
+   png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
+   do
+   {
+      if (!(png_ptr->zstream.avail_in))
+      {
+         while (!png_ptr->idat_size)
+         {
+            png_crc_finish(png_ptr, 0);
+
+            png_ptr->idat_size = png_read_chunk_header(png_ptr);
+            if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+               png_error(png_ptr, "Not enough image data");
+         }
+         png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
+         png_ptr->zstream.next_in = png_ptr->zbuf;
+         if (png_ptr->zbuf_size > png_ptr->idat_size)
+            png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
+         png_crc_read(png_ptr, png_ptr->zbuf,
+            (png_size_t)png_ptr->zstream.avail_in);
+         png_ptr->idat_size -= png_ptr->zstream.avail_in;
+      }
+      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+      if (ret == Z_STREAM_END)
+      {
+         if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
+            png_ptr->idat_size)
+            png_benign_error(png_ptr, "Extra compressed data");
+         png_ptr->mode |= PNG_AFTER_IDAT;
+         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+         break;
+      }
+      if (ret != Z_OK)
+         png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
+                   "Decompression error");
+
+   } while (png_ptr->zstream.avail_out);
+
+   png_ptr->row_info.color_type = png_ptr->color_type;
+   png_ptr->row_info.width = png_ptr->iwidth;
+   png_ptr->row_info.channels = png_ptr->channels;
+   png_ptr->row_info.bit_depth = png_ptr->bit_depth;
+   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
+   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+       png_ptr->row_info.width);
+
+   if (png_ptr->row_buf[0])
+   png_read_filter_row(png_ptr, &(png_ptr->row_info),
+      png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+      (int)(png_ptr->row_buf[0]));
+
+   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
+   {
+      /* Intrapixel differencing */
+      png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
+   }
+#endif
+
+
+   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
+      png_do_read_transformations(png_ptr);
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   /* Blow up interlaced rows to full size */
+   if (png_ptr->interlaced &&
+      (png_ptr->transformations & PNG_INTERLACE))
+   {
+      if (png_ptr->pass < 6)
+         /* Old interface (pre-1.0.9):
+          * png_do_read_interlace(&(png_ptr->row_info),
+          *    png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+          */
+         png_do_read_interlace(png_ptr);
+
+      if (dsp_row != NULL)
+         png_combine_row(png_ptr, dsp_row,
+            png_pass_dsp_mask[png_ptr->pass]);
+      if (row != NULL)
+         png_combine_row(png_ptr, row,
+            png_pass_mask[png_ptr->pass]);
+   }
+   else
+#endif
+   {
+      if (row != NULL)
+         png_combine_row(png_ptr, row, 0xff);
+      if (dsp_row != NULL)
+         png_combine_row(png_ptr, dsp_row, 0xff);
+   }
+   png_read_finish_row(png_ptr);
+
+   if (png_ptr->read_row_fn != NULL)
+      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
+}
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read one or more rows of image data.  If the image is interlaced,
+ * and png_set_interlace_handling() has been called, the rows need to
+ * contain the contents of the rows from the previous pass.  If the
+ * image has alpha or transparency, and png_handle_alpha()[*] has been
+ * called, the rows contents must be initialized to the contents of the
+ * screen.
+ *
+ * "row" holds the actual image, and pixels are placed in it
+ * as they arrive.  If the image is displayed after each pass, it will
+ * appear to "sparkle" in.  "display_row" can be used to display a
+ * "chunky" progressive image, with finer detail added as it becomes
+ * available.  If you do not want this "chunky" display, you may pass
+ * NULL for display_row.  If you do not want the sparkle display, and
+ * you have not called png_handle_alpha(), you may pass NULL for rows.
+ * If you have called png_handle_alpha(), and the image has either an
+ * alpha channel or a transparency chunk, you must provide a buffer for
+ * rows.  In this case, you do not have to provide a display_row buffer
+ * also, but you may.  If the image is not interlaced, or if you have
+ * not called png_set_interlace_handling(), the display_row buffer will
+ * be ignored, so pass NULL to it.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of this version of libpng
+ */
+
+void PNGAPI
+png_read_rows(png_structp png_ptr, png_bytepp row,
+   png_bytepp display_row, png_uint_32 num_rows)
+{
+   png_uint_32 i;
+   png_bytepp rp;
+   png_bytepp dp;
+
+   png_debug(1, "in png_read_rows");
+ 
+   if (png_ptr == NULL)
+      return;
+   rp = row;
+   dp = display_row;
+   if (rp != NULL && dp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep rptr = *rp++;
+         png_bytep dptr = *dp++;
+
+         png_read_row(png_ptr, rptr, dptr);
+      }
+   else if (rp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep rptr = *rp;
+         png_read_row(png_ptr, rptr, NULL);
+         rp++;
+      }
+   else if (dp != NULL)
+      for (i = 0; i < num_rows; i++)
+      {
+         png_bytep dptr = *dp;
+         png_read_row(png_ptr, NULL, dptr);
+         dp++;
+      }
+}
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the entire image.  If the image has an alpha channel or a tRNS
+ * chunk, and you have called png_handle_alpha()[*], you will need to
+ * initialize the image to the current image that PNG will be overlaying.
+ * We set the num_rows again here, in case it was incorrectly set in
+ * png_read_start_row() by a call to png_read_update_info() or
+ * png_start_read_image() if png_set_interlace_handling() wasn't called
+ * prior to either of these functions like it should have been.  You can
+ * only call this function once.  If you desire to have an image for
+ * each pass of a interlaced image, use png_read_rows() instead.
+ *
+ * [*] png_handle_alpha() does not exist yet, as of this version of libpng
+ */
+void PNGAPI
+png_read_image(png_structp png_ptr, png_bytepp image)
+{
+   png_uint_32 i, image_height;
+   int pass, j;
+   png_bytepp rp;
+
+   png_debug(1, "in png_read_image");
+ 
+   if (png_ptr == NULL)
+      return;
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   pass = png_set_interlace_handling(png_ptr);
+#else
+   if (png_ptr->interlaced)
+      png_error(png_ptr,
+        "Cannot read interlaced image -- interlace handler disabled");
+   pass = 1;
+#endif
+
+
+   image_height=png_ptr->height;
+   png_ptr->num_rows = image_height; /* Make sure this is set correctly */
+
+   for (j = 0; j < pass; j++)
+   {
+      rp = image;
+      for (i = 0; i < image_height; i++)
+      {
+         png_read_row(png_ptr, *rp, NULL);
+         rp++;
+      }
+   }
+}
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the end of the PNG file.  Will not read past the end of the
+ * file, will verify the end is accurate, and will read any comments
+ * or time information at the end of the file, if info is not NULL.
+ */
+void PNGAPI
+png_read_end(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_read_end");
+ 
+   if (png_ptr == NULL)
+      return;
+   png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
+
+   do
+   {
+      PNG_IHDR;
+      PNG_IDAT;
+      PNG_IEND;
+      PNG_PLTE;
+#ifdef PNG_READ_bKGD_SUPPORTED
+      PNG_bKGD;
+#endif
+#ifdef PNG_READ_cHRM_SUPPORTED
+      PNG_cHRM;
+#endif
+#ifdef PNG_READ_gAMA_SUPPORTED
+      PNG_gAMA;
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+      PNG_hIST;
+#endif
+#ifdef PNG_READ_iCCP_SUPPORTED
+      PNG_iCCP;
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+      PNG_iTXt;
+#endif
+#ifdef PNG_READ_oFFs_SUPPORTED
+      PNG_oFFs;
+#endif
+#ifdef PNG_READ_pCAL_SUPPORTED
+      PNG_pCAL;
+#endif
+#ifdef PNG_READ_pHYs_SUPPORTED
+      PNG_pHYs;
+#endif
+#ifdef PNG_READ_sBIT_SUPPORTED
+      PNG_sBIT;
+#endif
+#ifdef PNG_READ_sCAL_SUPPORTED
+      PNG_sCAL;
+#endif
+#ifdef PNG_READ_sPLT_SUPPORTED
+      PNG_sPLT;
+#endif
+#ifdef PNG_READ_sRGB_SUPPORTED
+      PNG_sRGB;
+#endif
+#ifdef PNG_READ_tEXt_SUPPORTED
+      PNG_tEXt;
+#endif
+#ifdef PNG_READ_tIME_SUPPORTED
+      PNG_tIME;
+#endif
+#ifdef PNG_READ_tRNS_SUPPORTED
+      PNG_tRNS;
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+      PNG_zTXt;
+#endif
+      png_uint_32 length = png_read_chunk_header(png_ptr);
+      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
+
+      if (!png_memcmp(chunk_name, png_IHDR, 4))
+         png_handle_IHDR(png_ptr, info_ptr, length);
+      else if (!png_memcmp(chunk_name, png_IEND, 4))
+         png_handle_IEND(png_ptr, info_ptr, length);
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+      else if (png_handle_as_unknown(png_ptr, chunk_name))
+      {
+         if (!png_memcmp(chunk_name, png_IDAT, 4))
+         {
+            if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+               png_benign_error(png_ptr, "Too many IDATs found");
+         }
+         png_handle_unknown(png_ptr, info_ptr, length);
+         if (!png_memcmp(chunk_name, png_PLTE, 4))
+            png_ptr->mode |= PNG_HAVE_PLTE;
+      }
+#endif
+      else if (!png_memcmp(chunk_name, png_IDAT, 4))
+      {
+         /* Zero length IDATs are legal after the last IDAT has been
+          * read, but not after other chunks have been read.
+          */
+         if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+            png_benign_error(png_ptr, "Too many IDATs found");
+         png_crc_finish(png_ptr, length);
+      }
+      else if (!png_memcmp(chunk_name, png_PLTE, 4))
+         png_handle_PLTE(png_ptr, info_ptr, length);
+#ifdef PNG_READ_bKGD_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_bKGD, 4))
+         png_handle_bKGD(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_cHRM_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_cHRM, 4))
+         png_handle_cHRM(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_gAMA_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_gAMA, 4))
+         png_handle_gAMA(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_hIST, 4))
+         png_handle_hIST(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_oFFs_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_oFFs, 4))
+         png_handle_oFFs(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_pCAL_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_pCAL, 4))
+         png_handle_pCAL(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sCAL_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sCAL, 4))
+         png_handle_sCAL(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_pHYs_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_pHYs, 4))
+         png_handle_pHYs(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sBIT_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sBIT, 4))
+         png_handle_sBIT(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sRGB_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sRGB, 4))
+         png_handle_sRGB(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_iCCP_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_iCCP, 4))
+         png_handle_iCCP(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_sPLT_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_sPLT, 4))
+         png_handle_sPLT(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_tEXt_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_tEXt, 4))
+         png_handle_tEXt(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_tIME_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_tIME, 4))
+         png_handle_tIME(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_tRNS_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_tRNS, 4))
+         png_handle_tRNS(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_zTXt, 4))
+         png_handle_zTXt(png_ptr, info_ptr, length);
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+      else if (!png_memcmp(chunk_name, png_iTXt, 4))
+         png_handle_iTXt(png_ptr, info_ptr, length);
+#endif
+      else
+         png_handle_unknown(png_ptr, info_ptr, length);
+   } while (!(png_ptr->mode & PNG_HAVE_IEND));
+}
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+
+/* Free all memory used by the read */
+void PNGAPI
+png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
+   png_infopp end_info_ptr_ptr)
+{
+   png_structp png_ptr = NULL;
+   png_infop info_ptr = NULL, end_info_ptr = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn = NULL;
+   png_voidp mem_ptr = NULL;
+#endif
+
+   png_debug(1, "in png_destroy_read_struct");
+ 
+   if (png_ptr_ptr != NULL)
+      png_ptr = *png_ptr_ptr;
+   if (png_ptr == NULL)
+      return;
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+   mem_ptr = png_ptr->mem_ptr;
+#endif
+
+   if (info_ptr_ptr != NULL)
+      info_ptr = *info_ptr_ptr;
+
+   if (end_info_ptr_ptr != NULL)
+      end_info_ptr = *end_info_ptr_ptr;
+
+   png_read_destroy(png_ptr, info_ptr, end_info_ptr);
+
+   if (info_ptr != NULL)
+   {
+#ifdef PNG_TEXT_SUPPORTED
+      png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
+#endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
+          (png_voidp)mem_ptr);
+#else
+      png_destroy_struct((png_voidp)info_ptr);
+#endif
+      *info_ptr_ptr = NULL;
+   }
+
+   if (end_info_ptr != NULL)
+   {
+#ifdef PNG_READ_TEXT_SUPPORTED
+      png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
+#endif
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
+         (png_voidp)mem_ptr);
+#else
+      png_destroy_struct((png_voidp)end_info_ptr);
+#endif
+      *end_info_ptr_ptr = NULL;
+   }
+
+   if (png_ptr != NULL)
+   {
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
+          (png_voidp)mem_ptr);
+#else
+      png_destroy_struct((png_voidp)png_ptr);
+#endif
+      *png_ptr_ptr = NULL;
+   }
+}
+
+/* Free all memory used by the read (old method) */
+void /* PRIVATE */
+png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
+{
+#ifdef PNG_SETJMP_SUPPORTED
+   jmp_buf tmp_jmp;
+#endif
+   png_error_ptr error_fn;
+   png_error_ptr warning_fn;
+   png_voidp error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn;
+#endif
+
+   png_debug(1, "in png_read_destroy");
+ 
+   if (info_ptr != NULL)
+      png_info_destroy(png_ptr, info_ptr);
+
+   if (end_info_ptr != NULL)
+      png_info_destroy(png_ptr, end_info_ptr);
+
+   png_free(png_ptr, png_ptr->zbuf);
+   png_free(png_ptr, png_ptr->big_row_buf);
+   png_free(png_ptr, png_ptr->prev_row);
+   png_free(png_ptr, png_ptr->chunkdata);
+#ifdef PNG_READ_DITHER_SUPPORTED
+   png_free(png_ptr, png_ptr->palette_lookup);
+   png_free(png_ptr, png_ptr->dither_index);
+#endif
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   png_free(png_ptr, png_ptr->gamma_table);
+#endif
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+   png_free(png_ptr, png_ptr->gamma_from_1);
+   png_free(png_ptr, png_ptr->gamma_to_1);
+#endif
+   if (png_ptr->free_me & PNG_FREE_PLTE)
+      png_zfree(png_ptr, png_ptr->palette);
+   png_ptr->free_me &= ~PNG_FREE_PLTE;
+#if defined(PNG_tRNS_SUPPORTED) || \
+    defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   if (png_ptr->free_me & PNG_FREE_TRNS)
+      png_free(png_ptr, png_ptr->trans_alpha);
+   png_ptr->free_me &= ~PNG_FREE_TRNS;
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+   if (png_ptr->free_me & PNG_FREE_HIST)
+      png_free(png_ptr, png_ptr->hist);
+   png_ptr->free_me &= ~PNG_FREE_HIST;
+#endif
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   if (png_ptr->gamma_16_table != NULL)
+   {
+      int i;
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
+      {
+         png_free(png_ptr, png_ptr->gamma_16_table[i]);
+      }
+   png_free(png_ptr, png_ptr->gamma_16_table);
+   }
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+   if (png_ptr->gamma_16_from_1 != NULL)
+   {
+      int i;
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
+      {
+         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
+      }
+   png_free(png_ptr, png_ptr->gamma_16_from_1);
+   }
+   if (png_ptr->gamma_16_to_1 != NULL)
+   {
+      int i;
+      int istop = (1 << (8 - png_ptr->gamma_shift));
+      for (i = 0; i < istop; i++)
+      {
+         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
+      }
+   png_free(png_ptr, png_ptr->gamma_16_to_1);
+   }
+#endif
+#endif
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+   png_free(png_ptr, png_ptr->time_buffer);
+#endif
+
+   inflateEnd(&png_ptr->zstream);
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+   png_free(png_ptr, png_ptr->save_buffer);
+#endif
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+#ifdef PNG_TEXT_SUPPORTED
+   png_free(png_ptr, png_ptr->current_text);
+#endif /* PNG_TEXT_SUPPORTED */
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+   /* Save the important info out of the png_struct, in case it is
+    * being used again.
+    */
+#ifdef PNG_SETJMP_SUPPORTED
+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+#endif
+
+   error_fn = png_ptr->error_fn;
+   warning_fn = png_ptr->warning_fn;
+   error_ptr = png_ptr->error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+#endif
+
+   png_memset(png_ptr, 0, png_sizeof(png_struct));
+
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
+   png_ptr->error_ptr = error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_ptr->free_fn = free_fn;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
+#endif
+
+}
+
+void PNGAPI
+png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
+{
+   if (png_ptr == NULL)
+      return;
+   png_ptr->read_row_fn = read_row_fn;
+}
+
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+void PNGAPI
+png_read_png(png_structp png_ptr, png_infop info_ptr,
+                           int transforms,
+                           voidp params)
+{
+   int row;
+
+   if (png_ptr == NULL)
+      return;
+
+   /* png_read_info() gives us all of the information from the
+    * PNG file before the first IDAT (image data chunk).
+    */
+   png_read_info(png_ptr, info_ptr);
+   if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
+      png_error(png_ptr, "Image is too high to process with png_read_png()");
+
+   /* -------------- image transformations start here ------------------- */
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+   /* Tell libpng to strip 16 bit/color files down to 8 bits per color.
+    */
+   if (transforms & PNG_TRANSFORM_STRIP_16)
+      png_set_strip_16(png_ptr);
+#endif
+
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+   /* Strip alpha bytes from the input data without combining with
+    * the background (not recommended).
+    */
+   if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
+      png_set_strip_alpha(png_ptr);
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
+   /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
+    * byte into separate bytes (useful for paletted and grayscale images).
+    */
+   if (transforms & PNG_TRANSFORM_PACKING)
+      png_set_packing(png_ptr);
+#endif
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+   /* Change the order of packed pixels to least significant bit first
+    * (not useful if you are using png_set_packing).
+    */
+   if (transforms & PNG_TRANSFORM_PACKSWAP)
+      png_set_packswap(png_ptr);
+#endif
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+   /* Expand paletted colors into true RGB triplets
+    * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel
+    * Expand paletted or RGB images with transparency to full alpha
+    * channels so the data will be available as RGBA quartets.
+    */
+   if (transforms & PNG_TRANSFORM_EXPAND)
+      if ((png_ptr->bit_depth < 8) ||
+          (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
+          (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
+         png_set_expand(png_ptr);
+#endif
+
+   /* We don't handle background color or gamma transformation or dithering.
+    */
+
+#ifdef PNG_READ_INVERT_SUPPORTED
+   /* Invert monochrome files to have 0 as white and 1 as black
+    */
+   if (transforms & PNG_TRANSFORM_INVERT_MONO)
+      png_set_invert_mono(png_ptr);
+#endif
+
+#ifdef PNG_READ_SHIFT_SUPPORTED
+   /* If you want to shift the pixel values from the range [0,255] or
+    * [0,65535] to the original [0,7] or [0,31], or whatever range the
+    * colors were originally in:
+    */
+   if ((transforms & PNG_TRANSFORM_SHIFT)
+       && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
+   {
+      png_color_8p sig_bit;
+
+      png_get_sBIT(png_ptr, info_ptr, &sig_bit);
+      png_set_shift(png_ptr, sig_bit);
+   }
+#endif
+
+#ifdef PNG_READ_BGR_SUPPORTED
+   /* Flip the RGB pixels to BGR (or RGBA to BGRA)
+    */
+   if (transforms & PNG_TRANSFORM_BGR)
+      png_set_bgr(png_ptr);
+#endif
+
+#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+   /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)
+    */
+   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
+       png_set_swap_alpha(png_ptr);
+#endif
+
+#ifdef PNG_READ_SWAP_SUPPORTED
+   /* Swap bytes of 16 bit files to least significant byte first
+    */
+   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
+      png_set_swap(png_ptr);
+#endif
+
+/* Added at libpng-1.2.41 */
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+   /* Invert the alpha channel from opacity to transparency
+    */
+   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
+       png_set_invert_alpha(png_ptr);
+#endif
+
+/* Added at libpng-1.2.41 */
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+   /* Expand grayscale image to RGB
+    */
+   if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)
+       png_set_gray_to_rgb(png_ptr);
+#endif
+
+   /* We don't handle adding filler bytes */
+
+   /* Optional call to gamma correct and add the background to the palette
+    * and update info structure.  REQUIRED if you are expecting libpng to
+    * update the palette for you (i.e., you selected such a transform above).
+    */
+   png_read_update_info(png_ptr, info_ptr);
+
+   /* -------------- image transformations end here ------------------- */
+
+   png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
+   if (info_ptr->row_pointers == NULL)
+   {
+    png_uint_32 iptr;
+
+      info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
+         info_ptr->height * png_sizeof(png_bytep));
+      for (iptr=0; iptr<info_ptr->height; iptr++)
+         info_ptr->row_pointers[iptr] = NULL;
+
+      info_ptr->free_me |= PNG_FREE_ROWS;
+
+      for (row = 0; row < (int)info_ptr->height; row++)
+         info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
+            png_get_rowbytes(png_ptr, info_ptr));
+   }
+
+   png_read_image(png_ptr, info_ptr->row_pointers);
+   info_ptr->valid |= PNG_INFO_IDAT;
+
+   /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
+   png_read_end(png_ptr, info_ptr);
+
+   transforms = transforms; /* Quiet compiler warnings */
+   params = params;
+
+}
+#endif /* PNG_INFO_IMAGE_SUPPORTED */
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED */
diff --git a/src/libpng/pngrio.c b/src/libpng/pngrio.c
index e5537da73..53f2a4527 100644
--- a/src/libpng/pngrio.c
+++ b/src/libpng/pngrio.c
@@ -1,179 +1,163 @@
-

-/* pngrio.c - functions for data input

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This file provides a location for all input.  Users who need

- * special handling are expected to write a function that has the same

- * arguments as this and performs a similar function, but that possibly

- * has a different input method.  Note that you shouldn't change this

- * function, but rather write a replacement function and then make

- * libpng use it at run time with png_set_read_fn(...).

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_READ_SUPPORTED

-

-/* Read the data from whatever input you are using.  The default routine

- * reads from a file pointer.  Note that this routine sometimes gets called

- * with very small lengths, so you should implement some kind of simple

- * buffering if you are using unbuffered reads.  This should never be asked

- * to read more then 64K on a 16 bit machine.

- */

-void /* PRIVATE */

-png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   png_debug1(4, "reading %d bytes", (int)length);

- 

-   if (png_ptr->read_data_fn != NULL)

-      (*(png_ptr->read_data_fn))(png_ptr, data, length);

-   else

-      png_error(png_ptr, "Call to NULL read function");

-}

-

-#ifdef PNG_STDIO_SUPPORTED

-/* 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

- * read_data function and use it at run time with png_set_read_fn(), rather

- * than changing the library.

- */

-#ifndef USE_FAR_KEYWORD

-void PNGAPI

-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   png_size_t check;

-

-   if (png_ptr == NULL)

-      return;

-   /* 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.

-    */

-#ifdef _WIN32_WCE

-   if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )

-      check = 0;

-#else

-   check = (png_size_t)fread(data, (png_size_t)1, length,

-      (png_FILE_p)png_ptr->io_ptr);

-#endif

-

-   if (check != length)

-      png_error(png_ptr, "Read Error");

-}

-#else

-/* This is the model-independent version. Since the standard I/O library

-   can't handle far buffers in the medium and small models, we have to copy

-   the data.

-*/

-

-#define NEAR_BUF_SIZE 1024

-#define MIN(a,b) (a <= b ? a : b)

-

-static void PNGAPI

-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   int check;

-   png_byte *n_data;

-   png_FILE_p io_ptr;

-

-   if (png_ptr == NULL)

-      return;

-   /* Check if data really is near. If so, use usual code. */

-   n_data = (png_byte *)CVT_PTR_NOCHECK(data);

-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

-   if ((png_bytep)n_data == data)

-   {

-#ifdef _WIN32_WCE

-      if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )

-         check = 0;

-#else

-      check = fread(n_data, 1, length, io_ptr);

-#endif

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t read, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         read = MIN(NEAR_BUF_SIZE, remaining);

-#ifdef _WIN32_WCE

-         if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) )

-            err = 0;

-#else

-         err = fread(buf, (png_size_t)1, read, io_ptr);

-#endif

-         png_memcpy(data, buf, read); /* copy far buffer to near buffer */

-         if (err != read)

-            break;

-         else

-            check += err;

-         data += read;

-         remaining -= read;

-      }

-      while (remaining != 0);

-   }

-   if ((png_uint_32)check != (png_uint_32)length)

-      png_error(png_ptr, "read Error");

-}

-#endif

-#endif

-

-/* This function allows the application to supply a new input function

- * for libpng if standard C streams aren't being used.

- *

- * This function takes as its arguments:

- * png_ptr      - pointer to a png input data structure

- * io_ptr       - pointer to user supplied structure containing info about

- *                the input functions.  May be NULL.

- * read_data_fn - pointer to a new input function that takes as its

- *                arguments a pointer to a png_struct, a pointer to

- *                a location where input data can be stored, and a 32-bit

- *                unsigned int that is the number of bytes to be read.

- *                To exit and output any fatal error messages the new write

- *                function should call png_error(png_ptr, "Error msg").

- *                May be NULL, in which case libpng's default function will

- *                be used.

- */

-void PNGAPI

-png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,

-   png_rw_ptr read_data_fn)

-{

-   if (png_ptr == NULL)

-      return;

-   png_ptr->io_ptr = io_ptr;

-

-#ifdef PNG_STDIO_SUPPORTED

-   if (read_data_fn != NULL)

-      png_ptr->read_data_fn = read_data_fn;

-   else

-      png_ptr->read_data_fn = png_default_read_data;

-#else

-   png_ptr->read_data_fn = read_data_fn;

-#endif

-

-   /* It is an error to write to a read device */

-   if (png_ptr->write_data_fn != NULL)

-   {

-      png_ptr->write_data_fn = NULL;

-      png_warning(png_ptr,

-         "It's an error to set both read_data_fn and write_data_fn in the ");

-      png_warning(png_ptr,

-         "same structure.  Resetting write_data_fn to NULL.");

-   }

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-   png_ptr->output_flush_fn = NULL;

-#endif

-}

-#endif /* PNG_READ_SUPPORTED */

+
+/* pngrio.c - functions for data input
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all input.  Users who need
+ * special handling are expected to write a function that has the same
+ * arguments as this and performs a similar function, but that possibly
+ * has a different input method.  Note that you shouldn't change this
+ * function, but rather write a replacement function and then make
+ * libpng use it at run time with png_set_read_fn(...).
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_READ_SUPPORTED
+#include "pngpriv.h"
+
+/* Read the data from whatever input you are using.  The default routine
+ * reads from a file pointer.  Note that this routine sometimes gets called
+ * with very small lengths, so you should implement some kind of simple
+ * buffering if you are using unbuffered reads.  This should never be asked
+ * to read more then 64K on a 16 bit machine.
+ */
+void /* PRIVATE */
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_debug1(4, "reading %d bytes", (int)length);
+ 
+   if (png_ptr->read_data_fn != NULL)
+      (*(png_ptr->read_data_fn))(png_ptr, data, length);
+   else
+      png_error(png_ptr, "Call to NULL read function");
+}
+
+#ifdef PNG_STDIO_SUPPORTED
+/* 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
+ * read_data function and use it at run time with png_set_read_fn(), rather
+ * than changing the library.
+ */
+#ifndef USE_FAR_KEYWORD
+void PNGAPI
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+
+   if (png_ptr == NULL)
+      return;
+   /* 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.
+    */
+   check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr);
+
+   if (check != length)
+      png_error(png_ptr, "Read Error");
+}
+#else
+/* This is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+static void PNGAPI
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+   png_byte *n_data;
+   png_FILE_p io_ptr;
+
+   if (png_ptr == NULL)
+      return;
+   /* Check if data really is near. If so, use usual code. */
+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)n_data == data)
+   {
+      check = fread(n_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t read, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         read = MIN(NEAR_BUF_SIZE, remaining);
+         err = fread(buf, 1, read, io_ptr);
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+         if (err != read)
+            break;
+         else
+            check += err;
+         data += read;
+         remaining -= read;
+      }
+      while (remaining != 0);
+   }
+   if ((png_uint_32)check != (png_uint_32)length)
+      png_error(png_ptr, "read Error");
+}
+#endif
+#endif
+
+/* This function allows the application to supply a new input function
+ * for libpng if standard C streams aren't being used.
+ *
+ * This function takes as its arguments:
+ * png_ptr      - pointer to a png input data structure
+ * io_ptr       - pointer to user supplied structure containing info about
+ *                the input functions.  May be NULL.
+ * read_data_fn - pointer to a new input function that takes as its
+ *                arguments a pointer to a png_struct, a pointer to
+ *                a location where input data can be stored, and a 32-bit
+ *                unsigned int that is the number of bytes to be read.
+ *                To exit and output any fatal error messages the new write
+ *                function should call png_error(png_ptr, "Error msg").
+ *                May be NULL, in which case libpng's default function will
+ *                be used.
+ */
+void PNGAPI
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
+   png_rw_ptr read_data_fn)
+{
+   if (png_ptr == NULL)
+      return;
+   png_ptr->io_ptr = io_ptr;
+
+#ifdef PNG_STDIO_SUPPORTED
+   if (read_data_fn != NULL)
+      png_ptr->read_data_fn = read_data_fn;
+   else
+      png_ptr->read_data_fn = png_default_read_data;
+#else
+   png_ptr->read_data_fn = read_data_fn;
+#endif
+
+   /* It is an error to write to a read device */
+   if (png_ptr->write_data_fn != NULL)
+   {
+      png_ptr->write_data_fn = NULL;
+      png_warning(png_ptr,
+         "It's an error to set both read_data_fn and write_data_fn in the ");
+      png_warning(png_ptr,
+         "same structure.  Resetting write_data_fn to NULL");
+   }
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+   png_ptr->output_flush_fn = NULL;
+#endif
+}
+#endif /* PNG_READ_SUPPORTED */
diff --git a/src/libpng/pngrtran.c b/src/libpng/pngrtran.c
index 1734754be..30aa5dc38 100644
--- a/src/libpng/pngrtran.c
+++ b/src/libpng/pngrtran.c
@@ -1,4446 +1,4195 @@
-

-/* pngrtran.c - transforms the data in a row for PNG readers

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This file contains functions optionally called by an application

- * in order to tell libpng how to handle data when reading a PNG.

- * Transformations that are used in both reading and writing are

- * in pngtrans.c.

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_READ_SUPPORTED

-

-/* Set the action on getting a CRC error for an ancillary or critical chunk. */

-void PNGAPI

-png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)

-{

-   png_debug(1, "in png_set_crc_action");

- 

-   if (png_ptr == NULL)

-      return;

-

-   /* Tell libpng how we react to CRC errors in critical chunks */

-   switch (crit_action)

-   {

-      case PNG_CRC_NO_CHANGE:                        /* Leave setting as is */

-         break;

-

-      case PNG_CRC_WARN_USE:                               /* Warn/use data */

-         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;

-         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;

-         break;

-

-      case PNG_CRC_QUIET_USE:                             /* Quiet/use data */

-         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;

-         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |

-                           PNG_FLAG_CRC_CRITICAL_IGNORE;

-         break;

-

-      case PNG_CRC_WARN_DISCARD:    /* Not a valid action for critical data */

-         png_warning(png_ptr,

-            "Can't discard critical data on CRC error.");

-      case PNG_CRC_ERROR_QUIT:                                /* Error/quit */

-

-      case PNG_CRC_DEFAULT:

-      default:

-         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;

-         break;

-   }

-

-   /* Tell libpng how we react to CRC errors in ancillary chunks */

-   switch (ancil_action)

-   {

-      case PNG_CRC_NO_CHANGE:                       /* Leave setting as is */

-         break;

-

-      case PNG_CRC_WARN_USE:                              /* Warn/use data */

-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

-         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;

-         break;

-

-      case PNG_CRC_QUIET_USE:                            /* Quiet/use data */

-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

-         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |

-                           PNG_FLAG_CRC_ANCILLARY_NOWARN;

-         break;

-

-      case PNG_CRC_ERROR_QUIT:                               /* Error/quit */

-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

-         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;

-         break;

-

-      case PNG_CRC_WARN_DISCARD:                      /* Warn/discard data */

-

-      case PNG_CRC_DEFAULT:

-      default:

-         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

-         break;

-   }

-}

-

-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \

-    defined(PNG_FLOATING_POINT_SUPPORTED)

-/* Handle alpha and tRNS via a background color */

-void PNGAPI

-png_set_background(png_structp png_ptr,

-   png_color_16p background_color, int background_gamma_code,

-   int need_expand, double background_gamma)

-{

-   png_debug(1, "in png_set_background");

- 

-   if (png_ptr == NULL)

-      return;

-   if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)

-   {

-      png_warning(png_ptr, "Application must supply a known background gamma");

-      return;

-   }

-

-   png_ptr->transformations |= PNG_BACKGROUND;

-   png_memcpy(&(png_ptr->background), background_color,

-      png_sizeof(png_color_16));

-   png_ptr->background_gamma = (float)background_gamma;

-   png_ptr->background_gamma_type = (png_byte)(background_gamma_code);

-   png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);

-}

-#endif

-

-#ifdef PNG_READ_16_TO_8_SUPPORTED

-/* Strip 16 bit depth files to 8 bit depth */

-void PNGAPI

-png_set_strip_16(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_strip_16");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_16_TO_8;

-}

-#endif

-

-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-void PNGAPI

-png_set_strip_alpha(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_strip_alpha");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;

-}

-#endif

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-/* Dither file to 8 bit.  Supply a palette, the current number

- * of elements in the palette, the maximum number of elements

- * allowed, and a histogram if possible.  If the current number

- * of colors is greater then the maximum number, the palette will be

- * modified to fit in the maximum number.  "full_dither" indicates

- * whether we need a dithering cube set up for RGB images, or if we

- * simply are reducing the number of colors in a paletted image.

- */

-

-typedef struct png_dsort_struct

-{

-   struct png_dsort_struct FAR * next;

-   png_byte left;

-   png_byte right;

-} png_dsort;

-typedef png_dsort FAR *       png_dsortp;

-typedef png_dsort FAR * FAR * png_dsortpp;

-

-void PNGAPI

-png_set_dither(png_structp png_ptr, png_colorp palette,

-   int num_palette, int maximum_colors, png_uint_16p histogram,

-   int full_dither)

-{

-   png_debug(1, "in png_set_dither");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_DITHER;

-

-   if (!full_dither)

-   {

-      int i;

-

-      png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,

-         (png_uint_32)(num_palette * png_sizeof(png_byte)));

-      for (i = 0; i < num_palette; i++)

-         png_ptr->dither_index[i] = (png_byte)i;

-   }

-

-   if (num_palette > maximum_colors)

-   {

-      if (histogram != NULL)

-      {

-         /* This is easy enough, just throw out the least used colors.

-          * Perhaps not the best solution, but good enough.

-          */

-

-         int i;

-

-         /* Initialize an array to sort colors */

-         png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(num_palette * png_sizeof(png_byte)));

-

-         /* Initialize the dither_sort array */

-         for (i = 0; i < num_palette; i++)

-            png_ptr->dither_sort[i] = (png_byte)i;

-

-         /* Find the least used palette entries by starting a

-          * bubble sort, and running it until we have sorted

-          * out enough colors.  Note that we don't care about

-          * sorting all the colors, just finding which are

-          * least used.

-          */

-

-         for (i = num_palette - 1; i >= maximum_colors; i--)

-         {

-            int done; /* To stop early if the list is pre-sorted */

-            int j;

-

-            done = 1;

-            for (j = 0; j < i; j++)

-            {

-               if (histogram[png_ptr->dither_sort[j]]

-                   < histogram[png_ptr->dither_sort[j + 1]])

-               {

-                  png_byte t;

-

-                  t = png_ptr->dither_sort[j];

-                  png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];

-                  png_ptr->dither_sort[j + 1] = t;

-                  done = 0;

-               }

-            }

-            if (done)

-               break;

-         }

-

-         /* Swap the palette around, and set up a table, if necessary */

-         if (full_dither)

-         {

-            int j = num_palette;

-

-            /* Put all the useful colors within the max, but don't

-             * move the others.

-             */

-            for (i = 0; i < maximum_colors; i++)

-            {

-               if ((int)png_ptr->dither_sort[i] >= maximum_colors)

-               {

-                  do

-                     j--;

-                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);

-                  palette[i] = palette[j];

-               }

-            }

-         }

-         else

-         {

-            int j = num_palette;

-

-            /* Move all the used colors inside the max limit, and

-             * develop a translation table.

-             */

-            for (i = 0; i < maximum_colors; i++)

-            {

-               /* Only move the colors we need to */

-               if ((int)png_ptr->dither_sort[i] >= maximum_colors)

-               {

-                  png_color tmp_color;

-

-                  do

-                     j--;

-                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);

-

-                  tmp_color = palette[j];

-                  palette[j] = palette[i];

-                  palette[i] = tmp_color;

-                  /* Indicate where the color went */

-                  png_ptr->dither_index[j] = (png_byte)i;

-                  png_ptr->dither_index[i] = (png_byte)j;

-               }

-            }

-

-            /* Find closest color for those colors we are not using */

-            for (i = 0; i < num_palette; i++)

-            {

-               if ((int)png_ptr->dither_index[i] >= maximum_colors)

-               {

-                  int min_d, k, min_k, d_index;

-

-                  /* Find the closest color to one we threw out */

-                  d_index = png_ptr->dither_index[i];

-                  min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);

-                  for (k = 1, min_k = 0; k < maximum_colors; k++)

-                  {

-                     int d;

-

-                     d = PNG_COLOR_DIST(palette[d_index], palette[k]);

-

-                     if (d < min_d)

-                     {

-                        min_d = d;

-                        min_k = k;

-                     }

-                  }

-                  /* Point to closest color */

-                  png_ptr->dither_index[i] = (png_byte)min_k;

-               }

-            }

-         }

-         png_free(png_ptr, png_ptr->dither_sort);

-         png_ptr->dither_sort = NULL;

-      }

-      else

-      {

-         /* This is much harder to do simply (and quickly).  Perhaps

-          * we need to go through a median cut routine, but those

-          * don't always behave themselves with only a few colors

-          * as input.  So we will just find the closest two colors,

-          * and throw out one of them (chosen somewhat randomly).

-          * [We don't understand this at all, so if someone wants to

-          *  work on improving it, be our guest - AED, GRP]

-          */

-         int i;

-         int max_d;

-         int num_new_palette;

-         png_dsortp t;

-         png_dsortpp hash;

-

-         t = NULL;

-

-         /* Initialize palette index arrays */

-         png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(num_palette * png_sizeof(png_byte)));

-         png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(num_palette * png_sizeof(png_byte)));

-

-         /* Initialize the sort array */

-         for (i = 0; i < num_palette; i++)

-         {

-            png_ptr->index_to_palette[i] = (png_byte)i;

-            png_ptr->palette_to_index[i] = (png_byte)i;

-         }

-

-         hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *

-            png_sizeof(png_dsortp)));

-

-         num_new_palette = num_palette;

-

-         /* Initial wild guess at how far apart the farthest pixel

-          * pair we will be eliminating will be.  Larger

-          * numbers mean more areas will be allocated, Smaller

-          * numbers run the risk of not saving enough data, and

-          * having to do this all over again.

-          *

-          * I have not done extensive checking on this number.

-          */

-         max_d = 96;

-

-         while (num_new_palette > maximum_colors)

-         {

-            for (i = 0; i < num_new_palette - 1; i++)

-            {

-               int j;

-

-               for (j = i + 1; j < num_new_palette; j++)

-               {

-                  int d;

-

-                  d = PNG_COLOR_DIST(palette[i], palette[j]);

-

-                  if (d <= max_d)

-                  {

-

-                     t = (png_dsortp)png_malloc_warn(png_ptr,

-                         (png_uint_32)(png_sizeof(png_dsort)));

-                     if (t == NULL)

-                         break;

-                     t->next = hash[d];

-                     t->left = (png_byte)i;

-                     t->right = (png_byte)j;

-                     hash[d] = t;

-                  }

-               }

-               if (t == NULL)

-                  break;

-            }

-

-            if (t != NULL)

-            for (i = 0; i <= max_d; i++)

-            {

-               if (hash[i] != NULL)

-               {

-                  png_dsortp p;

-

-                  for (p = hash[i]; p; p = p->next)

-                  {

-                     if ((int)png_ptr->index_to_palette[p->left]

-                        < num_new_palette &&

-                        (int)png_ptr->index_to_palette[p->right]

-                        < num_new_palette)

-                     {

-                        int j, next_j;

-

-                        if (num_new_palette & 0x01)

-                        {

-                           j = p->left;

-                           next_j = p->right;

-                        }

-                        else

-                        {

-                           j = p->right;

-                           next_j = p->left;

-                        }

-

-                        num_new_palette--;

-                        palette[png_ptr->index_to_palette[j]]

-                          = palette[num_new_palette];

-                        if (!full_dither)

-                        {

-                           int k;

-

-                           for (k = 0; k < num_palette; k++)

-                           {

-                              if (png_ptr->dither_index[k] ==

-                                 png_ptr->index_to_palette[j])

-                                 png_ptr->dither_index[k] =

-                                    png_ptr->index_to_palette[next_j];

-                              if ((int)png_ptr->dither_index[k] ==

-                                 num_new_palette)

-                                 png_ptr->dither_index[k] =

-                                    png_ptr->index_to_palette[j];

-                           }

-                        }

-

-                        png_ptr->index_to_palette[png_ptr->palette_to_index

-                           [num_new_palette]] = png_ptr->index_to_palette[j];

-                        png_ptr->palette_to_index[png_ptr->index_to_palette[j]]

-                           = png_ptr->palette_to_index[num_new_palette];

-

-                        png_ptr->index_to_palette[j] = (png_byte)num_new_palette;

-                        png_ptr->palette_to_index[num_new_palette] = (png_byte)j;

-                     }

-                     if (num_new_palette <= maximum_colors)

-                        break;

-                  }

-                  if (num_new_palette <= maximum_colors)

-                     break;

-               }

-            }

-

-            for (i = 0; i < 769; i++)

-            {

-               if (hash[i] != NULL)

-               {

-                  png_dsortp p = hash[i];

-                  while (p)

-                  {

-                     t = p->next;

-                     png_free(png_ptr, p);

-                     p = t;

-                  }

-               }

-               hash[i] = 0;

-            }

-            max_d += 96;

-         }

-         png_free(png_ptr, hash);

-         png_free(png_ptr, png_ptr->palette_to_index);

-         png_free(png_ptr, png_ptr->index_to_palette);

-         png_ptr->palette_to_index = NULL;

-         png_ptr->index_to_palette = NULL;

-      }

-      num_palette = maximum_colors;

-   }

-   if (png_ptr->palette == NULL)

-   {

-      png_ptr->palette = palette;

-   }

-   png_ptr->num_palette = (png_uint_16)num_palette;

-

-   if (full_dither)

-   {

-      int i;

-      png_bytep distance;

-      int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +

-         PNG_DITHER_BLUE_BITS;

-      int num_red = (1 << PNG_DITHER_RED_BITS);

-      int num_green = (1 << PNG_DITHER_GREEN_BITS);

-      int num_blue = (1 << PNG_DITHER_BLUE_BITS);

-      png_size_t num_entries = ((png_size_t)1 << total_bits);

-

-      png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr,

-         (png_uint_32)(num_entries * png_sizeof(png_byte)));

-

-      distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *

-         png_sizeof(png_byte)));

-      png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));

-

-      for (i = 0; i < num_palette; i++)

-      {

-         int ir, ig, ib;

-         int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));

-         int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));

-         int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));

-

-         for (ir = 0; ir < num_red; ir++)

-         {

-            /* int dr = abs(ir - r); */

-            int dr = ((ir > r) ? ir - r : r - ir);

-            int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));

-

-            for (ig = 0; ig < num_green; ig++)

-            {

-               /* int dg = abs(ig - g); */

-               int dg = ((ig > g) ? ig - g : g - ig);

-               int dt = dr + dg;

-               int dm = ((dr > dg) ? dr : dg);

-               int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);

-

-               for (ib = 0; ib < num_blue; ib++)

-               {

-                  int d_index = index_g | ib;

-                  /* int db = abs(ib - b); */

-                  int db = ((ib > b) ? ib - b : b - ib);

-                  int dmax = ((dm > db) ? dm : db);

-                  int d = dmax + dt + db;

-

-                  if (d < (int)distance[d_index])

-                  {

-                     distance[d_index] = (png_byte)d;

-                     png_ptr->palette_lookup[d_index] = (png_byte)i;

-                  }

-               }

-            }

-         }

-      }

-

-      png_free(png_ptr, distance);

-   }

-}

-#endif

-

-#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

-/* Transform the image from the file_gamma to the screen_gamma.  We

- * only do transformations on images where the file_gamma and screen_gamma

- * are not close reciprocals, otherwise it slows things down slightly, and

- * also needlessly introduces small errors.

- *

- * We will turn off gamma transformation later if no semitransparent entries

- * are present in the tRNS array for palette images.  We can't do it here

- * because we don't necessarily have the tRNS chunk yet.

- */

-void PNGAPI

-png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)

-{

-   png_debug(1, "in png_set_gamma");

-

-   if (png_ptr == NULL)

-      return;

-

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

-     png_ptr->transformations |= PNG_GAMMA;

-   png_ptr->gamma = (float)file_gamma;

-   png_ptr->screen_gamma = (float)scrn_gamma;

-}

-#endif

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-/* Expand paletted images to RGB, expand grayscale images of

- * less than 8-bit depth to 8-bit depth, and expand tRNS chunks

- * to alpha channels.

- */

-void PNGAPI

-png_set_expand(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_expand");

-

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

-   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

-}

-

-/* GRR 19990627:  the following three functions currently are identical

- *  to png_set_expand().  However, it is entirely reasonable that someone

- *  might wish to expand an indexed image to RGB but *not* expand a single,

- *  fully transparent palette entry to a full alpha channel--perhaps instead

- *  convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace

- *  the transparent color with a particular RGB value, or drop tRNS entirely.

- *  IOW, a future version of the library may make the transformations flag

- *  a bit more fine-grained, with separate bits for each of these three

- *  functions.

- *

- *  More to the point, these functions make it obvious what libpng will be

- *  doing, whereas "expand" can (and does) mean any number of things.

- *

- *  GRP 20060307: In libpng-1.2.9, png_set_gray_1_2_4_to_8() was modified

- *  to expand only the sample depth but not to expand the tRNS to alpha

- *  and its name was changed to png_set_expand_gray_1_2_4_to_8().

- */

-

-/* Expand paletted images to RGB. */

-void PNGAPI

-png_set_palette_to_rgb(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_palette_to_rgb");

-

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

-   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

-}

-

-#ifndef PNG_1_0_X

-/* Expand grayscale images of less than 8-bit depth to 8 bits. */

-void PNGAPI

-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");

-

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->transformations |= PNG_EXPAND;

-   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

-}

-#endif

-

-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

-/* Expand grayscale images of less than 8-bit depth to 8 bits. */

-/* Deprecated as of libpng-1.2.9 */

-void PNGAPI

-png_set_gray_1_2_4_to_8(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_gray_1_2_4_to_8");

-

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

-}

-#endif

-

-

-/* Expand tRNS chunks to alpha channels. */

-void PNGAPI

-png_set_tRNS_to_alpha(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_tRNS_to_alpha");

-

-   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

-   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

-}

-#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-void PNGAPI

-png_set_gray_to_rgb(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_gray_to_rgb");

-

-   png_ptr->transformations |= PNG_GRAY_TO_RGB;

-   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

-}

-#endif

-

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-/* Convert a RGB image to a grayscale of the same width.  This allows us,

- * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.

- */

-

-void PNGAPI

-png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,

-   double green)

-{

-   int red_fixed = (int)((float)red*100000.0 + 0.5);

-   int green_fixed = (int)((float)green*100000.0 + 0.5);

-   if (png_ptr == NULL)

-      return;

-   png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);

-}

-#endif

-

-void PNGAPI

-png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,

-   png_fixed_point red, png_fixed_point green)

-{

-   png_debug(1, "in png_set_rgb_to_gray");

-

-   if (png_ptr == NULL)

-      return;

-

-   switch(error_action)

-   {

-      case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;

-              break;

-

-      case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;

-              break;

-

-      case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;

-   }

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-#ifdef PNG_READ_EXPAND_SUPPORTED

-      png_ptr->transformations |= PNG_EXPAND;

-#else

-   {

-      png_warning(png_ptr,

-        "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");

-      png_ptr->transformations &= ~PNG_RGB_TO_GRAY;

-   }

-#endif

-   {

-      png_uint_16 red_int, green_int;

-      if (red < 0 || green < 0)

-      {

-         red_int   =  6968; /* .212671 * 32768 + .5 */

-         green_int = 23434; /* .715160 * 32768 + .5 */

-      }

-      else if (red + green < 100000L)

-      {

-         red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);

-         green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);

-      }

-      else

-      {

-         png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");

-         red_int   =  6968;

-         green_int = 23434;

-      }

-      png_ptr->rgb_to_gray_red_coeff   = red_int;

-      png_ptr->rgb_to_gray_green_coeff = green_int;

-      png_ptr->rgb_to_gray_blue_coeff  =

-         (png_uint_16)(32768 - red_int - green_int);

-   }

-}

-#endif

-

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_LEGACY_SUPPORTED) || \

-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

-void PNGAPI

-png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr

-   read_user_transform_fn)

-{

-   png_debug(1, "in png_set_read_user_transform_fn");

-

-   if (png_ptr == NULL)

-      return;

-

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-   png_ptr->transformations |= PNG_USER_TRANSFORM;

-   png_ptr->read_user_transform_fn = read_user_transform_fn;

-#endif

-#ifdef PNG_LEGACY_SUPPORTED

-   if (read_user_transform_fn)

-      png_warning(png_ptr,

-        "This version of libpng does not support user transforms");

-#endif

-}

-#endif

-

-/* Initialize everything needed for the read.  This includes modifying

- * the palette.

- */

-void /* PRIVATE */

-png_init_read_transformations(png_structp png_ptr)

-{

-   png_debug(1, "in png_init_read_transformations");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-  if (png_ptr != NULL)

-#endif

-  {

-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \

- || defined(PNG_READ_GAMMA_SUPPORTED)

-   int color_type = png_ptr->color_type;

-#endif

-

-#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   /* Detect gray background and attempt to enable optimization

-    * for gray --> RGB case

-    *

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

-    * background color might actually be gray yet not be flagged as such.

-    * This is not a problem for the current code, which uses

-    * PNG_BACKGROUND_IS_GRAY only to decide when to do the

-    * png_do_gray_to_rgb() transformation.

-    */

-   if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

-       !(color_type & PNG_COLOR_MASK_COLOR))

-   {

-          png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;

-   } else if ((png_ptr->transformations & PNG_BACKGROUND) &&

-              !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

-              (png_ptr->transformations & PNG_GRAY_TO_RGB) &&

-              png_ptr->background.red == png_ptr->background.green &&

-              png_ptr->background.red == png_ptr->background.blue)

-   {

-          png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;

-          png_ptr->background.gray = png_ptr->background.red;

-   }

-#endif

-

-   if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

-       (png_ptr->transformations & PNG_EXPAND))

-   {

-      if (!(color_type & PNG_COLOR_MASK_COLOR))  /* i.e., GRAY or GRAY_ALPHA */

-      {

-         /* Expand background and tRNS chunks */

-         switch (png_ptr->bit_depth)

-         {

-            case 1:

-               png_ptr->background.gray *= (png_uint_16)0xff;

-               png_ptr->background.red = png_ptr->background.green

-                 =  png_ptr->background.blue = png_ptr->background.gray;

-               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

-               {

-                 png_ptr->trans_values.gray *= (png_uint_16)0xff;

-                 png_ptr->trans_values.red = png_ptr->trans_values.green

-                   = png_ptr->trans_values.blue = png_ptr->trans_values.gray;

-               }

-               break;

-

-            case 2:

-               png_ptr->background.gray *= (png_uint_16)0x55;

-               png_ptr->background.red = png_ptr->background.green

-                 = png_ptr->background.blue = png_ptr->background.gray;

-               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

-               {

-                 png_ptr->trans_values.gray *= (png_uint_16)0x55;

-                 png_ptr->trans_values.red = png_ptr->trans_values.green

-                   = png_ptr->trans_values.blue = png_ptr->trans_values.gray;

-               }

-               break;

-

-            case 4:

-               png_ptr->background.gray *= (png_uint_16)0x11;

-               png_ptr->background.red = png_ptr->background.green

-                 = png_ptr->background.blue = png_ptr->background.gray;

-               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

-               {

-                 png_ptr->trans_values.gray *= (png_uint_16)0x11;

-                 png_ptr->trans_values.red = png_ptr->trans_values.green

-                   = png_ptr->trans_values.blue = png_ptr->trans_values.gray;

-               }

-               break;

-

-            case 8:

-

-            case 16:

-               png_ptr->background.red = png_ptr->background.green

-                 = png_ptr->background.blue = png_ptr->background.gray;

-               break;

-         }

-      }

-      else if (color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_ptr->background.red   =

-            png_ptr->palette[png_ptr->background.index].red;

-         png_ptr->background.green =

-            png_ptr->palette[png_ptr->background.index].green;

-         png_ptr->background.blue  =

-            png_ptr->palette[png_ptr->background.index].blue;

-

-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-        if (png_ptr->transformations & PNG_INVERT_ALPHA)

-        {

-#ifdef PNG_READ_EXPAND_SUPPORTED

-           if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

-#endif

-           {

-           /* Invert the alpha channel (in tRNS) unless the pixels are

-            * going to be expanded, in which case leave it for later

-            */

-              int i, istop;

-              istop=(int)png_ptr->num_trans;

-              for (i=0; i<istop; i++)

-                 png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);

-           }

-        }

-#endif

-

-      }

-   }

-#endif

-

-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)

-   png_ptr->background_1 = png_ptr->background;

-#endif

-#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

-

-   if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)

-       && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)

-         < PNG_GAMMA_THRESHOLD))

-   {

-    int i, k;

-    k=0;

-    for (i=0; i<png_ptr->num_trans; i++)

-    {

-      if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)

-        k=1; /* Partial transparency is present */

-    }

-    if (k == 0)

-      png_ptr->transformations &= ~PNG_GAMMA;

-   }

-

-   if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&

-        png_ptr->gamma != 0.0)

-   {

-      png_build_gamma_table(png_ptr);

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-      if (png_ptr->transformations & PNG_BACKGROUND)

-      {

-         if (color_type == PNG_COLOR_TYPE_PALETTE)

-         {

-           /* Could skip if no transparency */

-            png_color back, back_1;

-            png_colorp palette = png_ptr->palette;

-            int num_palette = png_ptr->num_palette;

-            int i;

-            if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)

-            {

-               back.red = png_ptr->gamma_table[png_ptr->background.red];

-               back.green = png_ptr->gamma_table[png_ptr->background.green];

-               back.blue = png_ptr->gamma_table[png_ptr->background.blue];

-

-               back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];

-               back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];

-               back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];

-            }

-            else

-            {

-               double g, gs;

-

-               switch (png_ptr->background_gamma_type)

-               {

-                  case PNG_BACKGROUND_GAMMA_SCREEN:

-                     g = (png_ptr->screen_gamma);

-                     gs = 1.0;

-                     break;

-

-                  case PNG_BACKGROUND_GAMMA_FILE:

-                     g = 1.0 / (png_ptr->gamma);

-                     gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

-                     break;

-

-                  case PNG_BACKGROUND_GAMMA_UNIQUE:

-                     g = 1.0 / (png_ptr->background_gamma);

-                     gs = 1.0 / (png_ptr->background_gamma *

-                                 png_ptr->screen_gamma);

-                     break;

-                  default:

-                     g = 1.0;    /* back_1 */

-                     gs = 1.0;   /* back */

-               }

-

-               if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)

-               {

-                  back.red   = (png_byte)png_ptr->background.red;

-                  back.green = (png_byte)png_ptr->background.green;

-                  back.blue  = (png_byte)png_ptr->background.blue;

-               }

-               else

-               {

-                  back.red = (png_byte)(pow(

-                     (double)png_ptr->background.red/255, gs) * 255.0 + .5);

-                  back.green = (png_byte)(pow(

-                     (double)png_ptr->background.green/255, gs) * 255.0 + .5);

-                  back.blue = (png_byte)(pow(

-                     (double)png_ptr->background.blue/255, gs) * 255.0 + .5);

-               }

-

-               back_1.red = (png_byte)(pow(

-                  (double)png_ptr->background.red/255, g) * 255.0 + .5);

-               back_1.green = (png_byte)(pow(

-                  (double)png_ptr->background.green/255, g) * 255.0 + .5);

-               back_1.blue = (png_byte)(pow(

-                  (double)png_ptr->background.blue/255, g) * 255.0 + .5);

-            }

-            for (i = 0; i < num_palette; i++)

-            {

-               if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)

-               {

-                  if (png_ptr->trans[i] == 0)

-                  {

-                     palette[i] = back;

-                  }

-                  else /* if (png_ptr->trans[i] != 0xff) */

-                  {

-                     png_byte v, w;

-

-                     v = png_ptr->gamma_to_1[palette[i].red];

-                     png_composite(w, v, png_ptr->trans[i], back_1.red);

-                     palette[i].red = png_ptr->gamma_from_1[w];

-

-                     v = png_ptr->gamma_to_1[palette[i].green];

-                     png_composite(w, v, png_ptr->trans[i], back_1.green);

-                     palette[i].green = png_ptr->gamma_from_1[w];

-

-                     v = png_ptr->gamma_to_1[palette[i].blue];

-                     png_composite(w, v, png_ptr->trans[i], back_1.blue);

-                     palette[i].blue = png_ptr->gamma_from_1[w];

-                  }

-               }

-               else

-               {

-                  palette[i].red = png_ptr->gamma_table[palette[i].red];

-                  palette[i].green = png_ptr->gamma_table[palette[i].green];

-                  palette[i].blue = png_ptr->gamma_table[palette[i].blue];

-               }

-            }

-            /* Prevent the transformations being done again, and make sure

-             * that the now spurious alpha channel is stripped - the code

-             * has just reduced background composition and gamma correction

-             * to a simple alpha channel strip.

-             */

-            png_ptr->transformations &= ~PNG_BACKGROUND;

-            png_ptr->transformations &= ~PNG_GAMMA;

-            png_ptr->transformations |= PNG_STRIP_ALPHA;

-         }

-         /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */

-         else

-         /* color_type != PNG_COLOR_TYPE_PALETTE */

-         {

-            double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);

-            double g = 1.0;

-            double gs = 1.0;

-

-            switch (png_ptr->background_gamma_type)

-            {

-               case PNG_BACKGROUND_GAMMA_SCREEN:

-                  g = (png_ptr->screen_gamma);

-                  gs = 1.0;

-                  break;

-

-               case PNG_BACKGROUND_GAMMA_FILE:

-                  g = 1.0 / (png_ptr->gamma);

-                  gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

-                  break;

-

-               case PNG_BACKGROUND_GAMMA_UNIQUE:

-                  g = 1.0 / (png_ptr->background_gamma);

-                  gs = 1.0 / (png_ptr->background_gamma *

-                     png_ptr->screen_gamma);

-                  break;

-            }

-

-            png_ptr->background_1.gray = (png_uint_16)(pow(

-               (double)png_ptr->background.gray / m, g) * m + .5);

-            png_ptr->background.gray = (png_uint_16)(pow(

-               (double)png_ptr->background.gray / m, gs) * m + .5);

-

-            if ((png_ptr->background.red != png_ptr->background.green) ||

-                (png_ptr->background.red != png_ptr->background.blue) ||

-                (png_ptr->background.red != png_ptr->background.gray))

-            {

-               /* RGB or RGBA with color background */

-               png_ptr->background_1.red = (png_uint_16)(pow(

-                  (double)png_ptr->background.red / m, g) * m + .5);

-               png_ptr->background_1.green = (png_uint_16)(pow(

-                  (double)png_ptr->background.green / m, g) * m + .5);

-               png_ptr->background_1.blue = (png_uint_16)(pow(

-                  (double)png_ptr->background.blue / m, g) * m + .5);

-               png_ptr->background.red = (png_uint_16)(pow(

-                  (double)png_ptr->background.red / m, gs) * m + .5);

-               png_ptr->background.green = (png_uint_16)(pow(

-                  (double)png_ptr->background.green / m, gs) * m + .5);

-               png_ptr->background.blue = (png_uint_16)(pow(

-                  (double)png_ptr->background.blue / m, gs) * m + .5);

-            }

-            else

-            {

-               /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */

-               png_ptr->background_1.red = png_ptr->background_1.green

-                 = png_ptr->background_1.blue = png_ptr->background_1.gray;

-               png_ptr->background.red = png_ptr->background.green

-                 = png_ptr->background.blue = png_ptr->background.gray;

-            }

-         }

-      }

-      else

-      /* Transformation does not include PNG_BACKGROUND */

-#endif /* PNG_READ_BACKGROUND_SUPPORTED */

-      if (color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_colorp palette = png_ptr->palette;

-         int num_palette = png_ptr->num_palette;

-         int i;

-

-         for (i = 0; i < num_palette; i++)

-         {

-            palette[i].red = png_ptr->gamma_table[palette[i].red];

-            palette[i].green = png_ptr->gamma_table[palette[i].green];

-            palette[i].blue = png_ptr->gamma_table[palette[i].blue];

-         }

-

-         /* Done the gamma correction. */

-         png_ptr->transformations &= ~PNG_GAMMA;

-      }

-   }

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   else

-#endif

-#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   /* No GAMMA transformation */

-   if ((png_ptr->transformations & PNG_BACKGROUND) &&

-       (color_type == PNG_COLOR_TYPE_PALETTE))

-   {

-      int i;

-      int istop = (int)png_ptr->num_trans;

-      png_color back;

-      png_colorp palette = png_ptr->palette;

-

-      back.red   = (png_byte)png_ptr->background.red;

-      back.green = (png_byte)png_ptr->background.green;

-      back.blue  = (png_byte)png_ptr->background.blue;

-

-      for (i = 0; i < istop; i++)

-      {

-         if (png_ptr->trans[i] == 0)

-         {

-            palette[i] = back;

-         }

-         else if (png_ptr->trans[i] != 0xff)

-         {

-            /* The png_composite() macro is defined in png.h */

-            png_composite(palette[i].red, palette[i].red,

-               png_ptr->trans[i], back.red);

-            png_composite(palette[i].green, palette[i].green,

-               png_ptr->trans[i], back.green);

-            png_composite(palette[i].blue, palette[i].blue,

-               png_ptr->trans[i], back.blue);

-         }

-      }

-

-      /* Handled alpha, still need to strip the channel. */

-      png_ptr->transformations &= ~PNG_BACKGROUND;

-      png_ptr->transformations |= PNG_STRIP_ALPHA;

-   }

-#endif /* PNG_READ_BACKGROUND_SUPPORTED */

-

-#ifdef PNG_READ_SHIFT_SUPPORTED

-   if ((png_ptr->transformations & PNG_SHIFT) &&

-      (color_type == PNG_COLOR_TYPE_PALETTE))

-   {

-      png_uint_16 i;

-      png_uint_16 istop = png_ptr->num_palette;

-      int sr = 8 - png_ptr->sig_bit.red;

-      int sg = 8 - png_ptr->sig_bit.green;

-      int sb = 8 - png_ptr->sig_bit.blue;

-

-      if (sr < 0 || sr > 8)

-         sr = 0;

-      if (sg < 0 || sg > 8)

-         sg = 0;

-      if (sb < 0 || sb > 8)

-         sb = 0;

-      for (i = 0; i < istop; i++)

-      {

-         png_ptr->palette[i].red >>= sr;

-         png_ptr->palette[i].green >>= sg;

-         png_ptr->palette[i].blue >>= sb;

-      }

-   }

-#endif  /* PNG_READ_SHIFT_SUPPORTED */

- }

-#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \

- && !defined(PNG_READ_BACKGROUND_SUPPORTED)

-   if (png_ptr)

-      return;

-#endif

-}

-

-/* Modify the info structure to reflect the transformations.  The

- * info should be updated so a PNG file could be written with it,

- * assuming the transformations result in valid PNG data.

- */

-void /* PRIVATE */

-png_read_transform_info(png_structp png_ptr, png_infop info_ptr)

-{

-   png_debug(1, "in png_read_transform_info");

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr->transformations & PNG_EXPAND)

-   {

-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         if (png_ptr->num_trans &&

-              (png_ptr->transformations & PNG_EXPAND_tRNS))

-            info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

-         else

-            info_ptr->color_type = PNG_COLOR_TYPE_RGB;

-         info_ptr->bit_depth = 8;

-         info_ptr->num_trans = 0;

-      }

-      else

-      {

-         if (png_ptr->num_trans)

-         {

-            if (png_ptr->transformations & PNG_EXPAND_tRNS)

-              info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

-         }

-         if (info_ptr->bit_depth < 8)

-            info_ptr->bit_depth = 8;

-         info_ptr->num_trans = 0;

-      }

-   }

-#endif

-

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   if (png_ptr->transformations & PNG_BACKGROUND)

-   {

-      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

-      info_ptr->num_trans = 0;

-      info_ptr->background = png_ptr->background;

-   }

-#endif

-

-#ifdef PNG_READ_GAMMA_SUPPORTED

-   if (png_ptr->transformations & PNG_GAMMA)

-   {

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-      info_ptr->gamma = png_ptr->gamma;

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-      info_ptr->int_gamma = png_ptr->int_gamma;

-#endif

-   }

-#endif

-

-#ifdef PNG_READ_16_TO_8_SUPPORTED

-   if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))

-      info_ptr->bit_depth = 8;

-#endif

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   if (png_ptr->transformations & PNG_GRAY_TO_RGB)

-      info_ptr->color_type |= PNG_COLOR_MASK_COLOR;

-#endif

-

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-   if (png_ptr->transformations & PNG_RGB_TO_GRAY)

-      info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;

-#endif

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-   if (png_ptr->transformations & PNG_DITHER)

-   {

-      if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||

-          (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&

-          png_ptr->palette_lookup && info_ptr->bit_depth == 8)

-      {

-         info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;

-      }

-   }

-#endif

-

-#ifdef PNG_READ_PACK_SUPPORTED

-   if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))

-      info_ptr->bit_depth = 8;

-#endif

-

-   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      info_ptr->channels = 1;

-   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)

-      info_ptr->channels = 3;

-   else

-      info_ptr->channels = 1;

-

-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

-      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

-#endif

-

-   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

-      info_ptr->channels++;

-

-#ifdef PNG_READ_FILLER_SUPPORTED

-   /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */

-   if ((png_ptr->transformations & PNG_FILLER) &&

-       ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||

-       (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))

-   {

-      info_ptr->channels++;

-      /* If adding a true alpha channel not just filler */

-#ifndef PNG_1_0_X

-      if (png_ptr->transformations & PNG_ADD_ALPHA)

-        info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

-#endif

-   }

-#endif

-

-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \

-defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

-     {

-       if (info_ptr->bit_depth < png_ptr->user_transform_depth)

-         info_ptr->bit_depth = png_ptr->user_transform_depth;

-       if (info_ptr->channels < png_ptr->user_transform_channels)

-         info_ptr->channels = png_ptr->user_transform_channels;

-     }

-#endif

-

-   info_ptr->pixel_depth = (png_byte)(info_ptr->channels *

-      info_ptr->bit_depth);

-

-   info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);

-

-#ifndef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr)

-      return;

-#endif

-}

-

-/* Transform the row.  The order of transformations is significant,

- * and is very touchy.  If you add a transformation, take care to

- * decide how it fits in with the other transformations here.

- */

-void /* PRIVATE */

-png_do_read_transformations(png_structp png_ptr)

-{

-   png_debug(1, "in png_do_read_transformations");

-

-   if (png_ptr->row_buf == NULL)

-   {

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-      char msg[50];

-

-      png_snprintf2(msg, 50,

-         "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,

-         png_ptr->pass);

-      png_error(png_ptr, msg);

-#else

-      png_error(png_ptr, "NULL row buffer");

-#endif

-   }

-#ifdef PNG_WARN_UNINITIALIZED_ROW

-   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

-      /* Application has failed to call either png_read_start_image()

-       * or png_read_update_info() after setting transforms that expand

-       * pixels.  This check added to libpng-1.2.19

-       */

-#if (PNG_WARN_UNINITIALIZED_ROW==1)

-      png_error(png_ptr, "Uninitialized row");

-#else

-      png_warning(png_ptr, "Uninitialized row");

-#endif

-#endif

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr->transformations & PNG_EXPAND)

-   {

-      if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,

-            png_ptr->palette, png_ptr->trans, png_ptr->num_trans);

-      }

-      else

-      {

-         if (png_ptr->num_trans &&

-             (png_ptr->transformations & PNG_EXPAND_tRNS))

-            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

-               &(png_ptr->trans_values));

-         else

-            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

-               NULL);

-      }

-   }

-#endif

-

-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

-      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));

-#endif

-

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-   if (png_ptr->transformations & PNG_RGB_TO_GRAY)

-   {

-      int rgb_error =

-         png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);

-      if (rgb_error)

-      {

-         png_ptr->rgb_to_gray_status=1;

-         if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==

-             PNG_RGB_TO_GRAY_WARN)

-            png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");

-         if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==

-             PNG_RGB_TO_GRAY_ERR)

-            png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");

-      }

-   }

-#endif

-

-/* From Andreas Dilger e-mail to png-implement, 26 March 1998:

- *

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

- *   pixel is transparent.  You would also need to make sure that the

- *   transparency information is upgraded to RGB.

- *

- *   To summarize, the current flow is:

- *   - Gray + simple transparency -> compare 1 or 2 gray bytes and composite

- *                                   with background "in place" if transparent,

- *                                   convert to RGB if necessary

- *   - Gray + alpha -> composite with gray background and remove alpha bytes,

- *                                   convert to RGB if necessary

- *

- *   To support RGB backgrounds for gray images we need:

- *   - Gray + simple transparency -> convert to RGB + simple transparency,

- *                                   compare 3 or 6 bytes and composite with

- *                                   background "in place" if transparent

- *                                   (3x compare/pixel compared to doing

- *                                   composite with gray bkgrnd)

- *   - Gray + alpha -> convert to RGB + alpha, composite with background and

- *                                   remove alpha bytes (3x float

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

- *  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.

- */

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   /* If gray -> RGB, do so now only if background is non-gray; else do later

-    * for performance reasons

-    */

-   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&

-       !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))

-      png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_16_TO_8_SUPPORTED

-   if (png_ptr->transformations & PNG_16_TO_8)

-      png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   if ((png_ptr->transformations & PNG_BACKGROUND) &&

-      ((png_ptr->num_trans != 0 ) ||

-      (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))

-      png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         &(png_ptr->trans_values), &(png_ptr->background)

-#ifdef PNG_READ_GAMMA_SUPPORTED

-         , &(png_ptr->background_1),

-         png_ptr->gamma_table, png_ptr->gamma_from_1,

-         png_ptr->gamma_to_1, png_ptr->gamma_16_table,

-         png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,

-         png_ptr->gamma_shift

-#endif

-);

-#endif

-

-#ifdef PNG_READ_GAMMA_SUPPORTED

-   if ((png_ptr->transformations & PNG_GAMMA) &&

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-       !((png_ptr->transformations & PNG_BACKGROUND) &&

-       ((png_ptr->num_trans != 0) ||

-       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&

-#endif

-       (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))

-      png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,

-          png_ptr->gamma_table, png_ptr->gamma_16_table,

-          png_ptr->gamma_shift);

-#endif

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-   if (png_ptr->transformations & PNG_DITHER)

-   {

-      png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,

-         png_ptr->palette_lookup, png_ptr->dither_index);

-      if (png_ptr->row_info.rowbytes == (png_uint_32)0)

-         png_error(png_ptr, "png_do_dither returned rowbytes=0");

-   }

-#endif

-

-#ifdef PNG_READ_INVERT_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_MONO)

-      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_SHIFT_SUPPORTED

-   if (png_ptr->transformations & PNG_SHIFT)

-      png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         &(png_ptr->shift));

-#endif

-

-#ifdef PNG_READ_PACK_SUPPORTED

-   if (png_ptr->transformations & PNG_PACK)

-      png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_BGR_SUPPORTED

-   if (png_ptr->transformations & PNG_BGR)

-      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_PACKSWAP)

-      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   /* If gray -> RGB, do so now only if we did not do so above */

-   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&

-       (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))

-      png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_FILLER_SUPPORTED

-   if (png_ptr->transformations & PNG_FILLER)

-      png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         (png_uint_32)png_ptr->filler, png_ptr->flags);

-#endif

-

-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_ALPHA)

-      png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_ALPHA)

-      png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_SWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_BYTES)

-      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

-    {

-      if (png_ptr->read_user_transform_fn != NULL)

-         (*(png_ptr->read_user_transform_fn)) /* User read transform function */

-            (png_ptr,                    /* png_ptr */

-               &(png_ptr->row_info),     /* row_info: */

-               /*  png_uint_32 width;       width of row */

-               /*  png_uint_32 rowbytes;    number of bytes in row */

-               /*  png_byte color_type;     color type of pixels */

-               /*  png_byte bit_depth;      bit depth of samples */

-               /*  png_byte channels;       number of channels (1-4) */

-               /*  png_byte pixel_depth;    bits per pixel (depth*channels) */

-               png_ptr->row_buf + 1);    /* start of pixel data for row */

-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

-      if (png_ptr->user_transform_depth)

-         png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;

-      if (png_ptr->user_transform_channels)

-         png_ptr->row_info.channels = png_ptr->user_transform_channels;

-#endif

-      png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

-         png_ptr->row_info.channels);

-      png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-         png_ptr->row_info.width);

-   }

-#endif

-

-}

-

-#ifdef PNG_READ_PACK_SUPPORTED

-/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,

- * without changing the actual values.  Thus, if you had a row with

- * a bit depth of 1, you would end up with bytes that only contained

- * the numbers 0 or 1.  If you would rather they contain 0 and 255, use

- * png_do_shift() after this.

- */

-void /* PRIVATE */

-png_do_unpack(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_unpack");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL && row_info->bit_depth < 8)

-#else

-   if (row_info->bit_depth < 8)

-#endif

-   {

-      png_uint_32 i;

-      png_uint_32 row_width=row_info->width;

-

-      switch (row_info->bit_depth)

-      {

-         case 1:

-         {

-            png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);

-            png_bytep dp = row + (png_size_t)row_width - 1;

-            png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);

-            for (i = 0; i < row_width; i++)

-            {

-               *dp = (png_byte)((*sp >> shift) & 0x01);

-               if (shift == 7)

-               {

-                  shift = 0;

-                  sp--;

-               }

-               else

-                  shift++;

-

-               dp--;

-            }

-            break;

-         }

-

-         case 2:

-         {

-

-            png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);

-            png_bytep dp = row + (png_size_t)row_width - 1;

-            png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

-            for (i = 0; i < row_width; i++)

-            {

-               *dp = (png_byte)((*sp >> shift) & 0x03);

-               if (shift == 6)

-               {

-                  shift = 0;

-                  sp--;

-               }

-               else

-                  shift += 2;

-

-               dp--;

-            }

-            break;

-         }

-

-         case 4:

-         {

-            png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);

-            png_bytep dp = row + (png_size_t)row_width - 1;

-            png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);

-            for (i = 0; i < row_width; i++)

-            {

-               *dp = (png_byte)((*sp >> shift) & 0x0f);

-               if (shift == 4)

-               {

-                  shift = 0;

-                  sp--;

-               }

-               else

-                  shift = 4;

-

-               dp--;

-            }

-            break;

-         }

-      }

-      row_info->bit_depth = 8;

-      row_info->pixel_depth = (png_byte)(8 * row_info->channels);

-      row_info->rowbytes = row_width * row_info->channels;

-   }

-}

-#endif

-

-#ifdef PNG_READ_SHIFT_SUPPORTED

-/* Reverse the effects of png_do_shift.  This routine merely shifts the

- * pixels back to their significant bits values.  Thus, if you have

- * a row of bit depth 8, but only 5 are significant, this will shift

- * the values back to 0 through 31.

- */

-void /* PRIVATE */

-png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)

-{

-   png_debug(1, "in png_do_unshift");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL && sig_bits != NULL &&

-#endif

-       row_info->color_type != PNG_COLOR_TYPE_PALETTE)

-   {

-      int shift[4];

-      int channels = 0;

-      int c;

-      png_uint_16 value = 0;

-      png_uint_32 row_width = row_info->width;

-

-      if (row_info->color_type & PNG_COLOR_MASK_COLOR)

-      {

-         shift[channels++] = row_info->bit_depth - sig_bits->red;

-         shift[channels++] = row_info->bit_depth - sig_bits->green;

-         shift[channels++] = row_info->bit_depth - sig_bits->blue;

-      }

-      else

-      {

-         shift[channels++] = row_info->bit_depth - sig_bits->gray;

-      }

-      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

-      {

-         shift[channels++] = row_info->bit_depth - sig_bits->alpha;

-      }

-

-      for (c = 0; c < channels; c++)

-      {

-         if (shift[c] <= 0)

-            shift[c] = 0;

-         else

-            value = 1;

-      }

-

-      if (!value)

-         return;

-

-      switch (row_info->bit_depth)

-      {

-         case 2:

-         {

-            png_bytep bp;

-            png_uint_32 i;

-            png_uint_32 istop = row_info->rowbytes;

-

-            for (bp = row, i = 0; i < istop; i++)

-            {

-               *bp >>= 1;

-               *bp++ &= 0x55;

-            }

-            break;

-         }

-

-         case 4:

-         {

-            png_bytep bp = row;

-            png_uint_32 i;

-            png_uint_32 istop = row_info->rowbytes;

-            png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |

-               (png_byte)((int)0xf >> shift[0]));

-

-            for (i = 0; i < istop; i++)

-            {

-               *bp >>= shift[0];

-               *bp++ &= mask;

-            }

-            break;

-         }

-

-         case 8:

-         {

-            png_bytep bp = row;

-            png_uint_32 i;

-            png_uint_32 istop = row_width * channels;

-

-            for (i = 0; i < istop; i++)

-            {

-               *bp++ >>= shift[i%channels];

-            }

-            break;

-         }

-

-         case 16:

-         {

-            png_bytep bp = row;

-            png_uint_32 i;

-            png_uint_32 istop = channels * row_width;

-

-            for (i = 0; i < istop; i++)

-            {

-               value = (png_uint_16)((*bp << 8) + *(bp + 1));

-               value >>= shift[i%channels];

-               *bp++ = (png_byte)(value >> 8);

-               *bp++ = (png_byte)(value & 0xff);

-            }

-            break;

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_READ_16_TO_8_SUPPORTED

-/* Chop rows of bit depth 16 down to 8 */

-void /* PRIVATE */

-png_do_chop(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_chop");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL && row_info->bit_depth == 16)

-#else

-   if (row_info->bit_depth == 16)

-#endif

-   {

-      png_bytep sp = row;

-      png_bytep dp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->width * row_info->channels;

-

-      for (i = 0; i<istop; i++, sp += 2, dp++)

-      {

-#ifdef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED

-      /* This does a more accurate scaling of the 16-bit color

-       * value, rather than a simple low-byte truncation.

-       *

-       * What the ideal calculation should be:

-       *   *dp = (((((png_uint_32)(*sp) << 8) |

-       *          (png_uint_32)(*(sp + 1))) * 255 + 127)

-       *          / (png_uint_32)65535L;

-       *

-       * GRR: no, I think this is what it really should be:

-       *   *dp = (((((png_uint_32)(*sp) << 8) |

-       *           (png_uint_32)(*(sp + 1))) + 128L)

-       *           / (png_uint_32)257L;

-       *

-       * GRR: here's the exact calculation with shifts:

-       *   temp = (((png_uint_32)(*sp) << 8) |

-       *           (png_uint_32)(*(sp + 1))) + 128L;

-       *   *dp = (temp - (temp >> 8)) >> 8;

-       *

-       * Approximate calculation with shift/add instead of multiply/divide:

-       *   *dp = ((((png_uint_32)(*sp) << 8) |

-       *          (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;

-       *

-       * What we actually do to avoid extra shifting and conversion:

-       */

-

-         *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);

-#else

-       /* Simply discard the low order byte */

-         *dp = *sp;

-#endif

-      }

-      row_info->bit_depth = 8;

-      row_info->pixel_depth = (png_byte)(8 * row_info->channels);

-      row_info->rowbytes = row_info->width * row_info->channels;

-   }

-}

-#endif

-

-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

-void /* PRIVATE */

-png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_read_swap_alpha");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL)

-#endif

-   {

-      png_uint_32 row_width = row_info->width;

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This converts from RGBA to ARGB */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               save = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save;

-            }

-         }

-         /* This converts from RRGGBBAA to AARRGGBB */

-         else

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save[2];

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               save[0] = *(--sp);

-               save[1] = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save[0];

-               *(--dp) = save[1];

-            }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This converts from GA to AG */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               save = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save;

-            }

-         }

-         /* This converts from GGAA to AAGG */

-         else

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save[2];

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               save[0] = *(--sp);

-               save[1] = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save[0];

-               *(--dp) = save[1];

-            }

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-void /* PRIVATE */

-png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_read_invert_alpha");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL)

-#endif

-   {

-      png_uint_32 row_width = row_info->width;

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This inverts the alpha channel in RGBA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = (png_byte)(255 - *(--sp));

-

-/*             This does nothing:

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               We can replace it with:

-*/

-               sp-=3;

-               dp=sp;

-            }

-         }

-         /* This inverts the alpha channel in RRGGBBAA */

-         else

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = (png_byte)(255 - *(--sp));

-               *(--dp) = (png_byte)(255 - *(--sp));

-

-/*             This does nothing:

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               We can replace it with:

-*/

-               sp-=6;

-               dp=sp;

-            }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This inverts the alpha channel in GA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = (png_byte)(255 - *(--sp));

-               *(--dp) = *(--sp);

-            }

-         }

-         /* This inverts the alpha channel in GGAA */

-         else

-         {

-            png_bytep sp  = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = (png_byte)(255 - *(--sp));

-               *(--dp) = (png_byte)(255 - *(--sp));

-/*

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-*/

-               sp-=2;

-               dp=sp;

-            }

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_READ_FILLER_SUPPORTED

-/* Add filler channel if we have RGB color */

-void /* PRIVATE */

-png_do_read_filler(png_row_infop row_info, png_bytep row,

-   png_uint_32 filler, png_uint_32 flags)

-{

-   png_uint_32 i;

-   png_uint_32 row_width = row_info->width;

-

-   png_byte hi_filler = (png_byte)((filler>>8) & 0xff);

-   png_byte lo_filler = (png_byte)(filler & 0xff);

-

-   png_debug(1, "in png_do_read_filler");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL  && row_info != NULL &&

-#endif

-       row_info->color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      if (row_info->bit_depth == 8)

-      {

-         /* This changes the data from G to GX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width;

-            png_bytep dp =  sp + (png_size_t)row_width;

-            for (i = 1; i < row_width; i++)

-            {

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

-            }

-            *(--dp) = lo_filler;

-            row_info->channels = 2;

-            row_info->pixel_depth = 16;

-            row_info->rowbytes = row_width * 2;

-         }

-      /* This changes the data from G to XG */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width;

-            png_bytep dp = sp  + (png_size_t)row_width;

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = *(--sp);

-               *(--dp) = lo_filler;

-            }

-            row_info->channels = 2;

-            row_info->pixel_depth = 16;

-            row_info->rowbytes = row_width * 2;

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         /* This changes the data from GG to GGXX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 1; i < row_width; i++)

-            {

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-            }

-            *(--dp) = hi_filler;

-            *(--dp) = lo_filler;

-            row_info->channels = 2;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-         /* This changes the data from GG to XXGG */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

-            }

-            row_info->channels = 2;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-      }

-   } /* COLOR_TYPE == GRAY */

-   else if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-   {

-      if (row_info->bit_depth == 8)

-      {

-         /* This changes the data from RGB to RGBX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 3;

-            png_bytep dp = sp  + (png_size_t)row_width;

-            for (i = 1; i < row_width; i++)

-            {

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-            }

-            *(--dp) = lo_filler;

-            row_info->channels = 4;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-      /* This changes the data from RGB to XRGB */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 3;

-            png_bytep dp = sp + (png_size_t)row_width;

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = lo_filler;

-            }

-            row_info->channels = 4;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         /* This changes the data from RRGGBB to RRGGBBXX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 6;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 1; i < row_width; i++)

-            {

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-            }

-            *(--dp) = hi_filler;

-            *(--dp) = lo_filler;

-            row_info->channels = 4;

-            row_info->pixel_depth = 64;

-            row_info->rowbytes = row_width * 8;

-         }

-         /* This changes the data from RRGGBB to XXRRGGBB */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 6;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

-            {

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

-            }

-            row_info->channels = 4;

-            row_info->pixel_depth = 64;

-            row_info->rowbytes = row_width * 8;

-         }

-      }

-   } /* COLOR_TYPE == RGB */

-}

-#endif

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-/* Expand grayscale files to RGB, with or without alpha */

-void /* PRIVATE */

-png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)

-{

-   png_uint_32 i;

-   png_uint_32 row_width = row_info->width;

-

-   png_debug(1, "in png_do_gray_to_rgb");

-

-   if (row_info->bit_depth >= 8 &&

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-      !(row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + (png_size_t)row_width - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

-            {

-               *(dp--) = *sp;

-               *(dp--) = *sp;

-               *(dp--) = *(sp--);

-            }

-         }

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2 - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 4;

-            for (i = 0; i < row_width; i++)

-            {

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *(sp--);

-               *(dp--) = *(sp--);

-            }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2 - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

-            {

-               *(dp--) = *(sp--);

-               *(dp--) = *sp;

-               *(dp--) = *sp;

-               *(dp--) = *(sp--);

-            }

-         }

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 4 - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 4;

-            for (i = 0; i < row_width; i++)

-            {

-               *(dp--) = *(sp--);

-               *(dp--) = *(sp--);

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *(sp--);

-               *(dp--) = *(sp--);

-            }

-         }

-      }

-      row_info->channels += (png_byte)2;

-      row_info->color_type |= PNG_COLOR_MASK_COLOR;

-      row_info->pixel_depth = (png_byte)(row_info->channels *

-         row_info->bit_depth);

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-   }

-}

-#endif

-

-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-/* Reduce RGB files to grayscale, with or without alpha

- * using the equation given in Poynton's ColorFAQ at

- * <http://www.inforamp.net/~poynton/>  (THIS LINK IS DEAD June 2008)

- * New link:

- * <http://www.poynton.com/notes/colour_and_gamma/>

- * Charles Poynton poynton at poynton.com

- *

- *     Y = 0.212671 * R + 0.715160 * G + 0.072169 * B

- *

- *  We approximate this with

- *

- *     Y = 0.21268 * R    + 0.7151 * G    + 0.07217 * B

- *

- *  which can be expressed with integers as

- *

- *     Y = (6969 * R + 23434 * G + 2365 * B)/32768

- *

- *  The calculation is to be done in a linear colorspace.

- *

- *  Other integer coefficents can be used via png_set_rgb_to_gray().

- */

-int /* PRIVATE */

-png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)

-

-{

-   png_uint_32 i;

-

-   png_uint_32 row_width = row_info->width;

-   int rgb_error = 0;

-

-   png_debug(1, "in png_do_rgb_to_gray");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-      (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;

-      png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;

-      png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;

-

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-      {

-         if (row_info->bit_depth == 8)

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte green = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

-                  if (red != green || red != blue)

-                  {

-                     rgb_error |= 1;

-                     *(dp++) = png_ptr->gamma_from_1[

-                       (rc*red + gc*green + bc*blue)>>15];

-                  }

-                  else

-                     *(dp++) = *(sp - 1);

-               }

-            }

-            else

-#endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = *(sp++);

-                  png_byte green = *(sp++);

-                  png_byte blue  = *(sp++);

-                  if (red != green || red != blue)

-                  {

-                     rgb_error |= 1;

-                     *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);

-                  }

-                  else

-                     *(dp++) = *(sp - 1);

-               }

-            }

-         }

-

-         else /* RGB bit_depth == 16 */

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_16_to_1 != NULL &&

-                png_ptr->gamma_16_from_1 != NULL)

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, w;

-

-                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-

-                  if (red == green && red == blue)

-                     w = red;

-                  else

-                  {

-                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

-                                  png_ptr->gamma_shift][red>>8];

-                     png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>

-                                  png_ptr->gamma_shift][green>>8];

-                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

-                                  png_ptr->gamma_shift][blue>>8];

-                     png_uint_16 gray16  = (png_uint_16)((rc*red_1 + gc*green_1

-                                  + bc*blue_1)>>15);

-                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

-                         png_ptr->gamma_shift][gray16 >> 8];

-                     rgb_error |= 1;

-                  }

-

-                  *(dp++) = (png_byte)((w>>8) & 0xff);

-                  *(dp++) = (png_byte)(w & 0xff);

-               }

-            }

-            else

-#endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, gray16;

-

-                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);

-                  *(dp++) = (png_byte)((gray16>>8) & 0xff);

-                  *(dp++) = (png_byte)(gray16 & 0xff);

-               }

-            }

-         }

-      }

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         if (row_info->bit_depth == 8)

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte green = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  *(dp++) =  png_ptr->gamma_from_1

-                             [(rc*red + gc*green + bc*blue)>>15];

-                  *(dp++) = *(sp++);  /* alpha */

-               }

-            }

-            else

-#endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = *(sp++);

-                  png_byte green = *(sp++);

-                  png_byte blue  = *(sp++);

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  *(dp++) =  (png_byte)((rc*red + gc*green + bc*blue)>>15);

-                  *(dp++) = *(sp++);  /* alpha */

-               }

-            }

-         }

-         else /* RGBA bit_depth == 16 */

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_16_to_1 != NULL &&

-                png_ptr->gamma_16_from_1 != NULL)

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, w;

-

-                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-

-                  if (red == green && red == blue)

-                     w = red;

-                  else

-                  {

-                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

-                                  png_ptr->gamma_shift][red>>8];

-                     png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>

-                                  png_ptr->gamma_shift][green>>8];

-                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

-                                  png_ptr->gamma_shift][blue>>8];

-                     png_uint_16 gray16  = (png_uint_16)((rc * red_1

-                                  + gc * green_1 + bc * blue_1)>>15);

-                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

-                         png_ptr->gamma_shift][gray16 >> 8];

-                     rgb_error |= 1;

-                  }

-

-                  *(dp++) = (png_byte)((w>>8) & 0xff);

-                  *(dp++) = (png_byte)(w & 0xff);

-                  *(dp++) = *(sp++);  /* alpha */

-                  *(dp++) = *(sp++);

-               }

-            }

-            else

-#endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, gray16;

-                  red   = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);

-                  *(dp++) = (png_byte)((gray16>>8) & 0xff);

-                  *(dp++) = (png_byte)(gray16 & 0xff);

-                  *(dp++) = *(sp++);  /* alpha */

-                  *(dp++) = *(sp++);

-               }

-            }

-         }

-      }

-   row_info->channels -= (png_byte)2;

-      row_info->color_type &= ~PNG_COLOR_MASK_COLOR;

-      row_info->pixel_depth = (png_byte)(row_info->channels *

-         row_info->bit_depth);

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-   }

-   return rgb_error;

-}

-#endif

-

-/* Build a grayscale palette.  Palette is assumed to be 1 << bit_depth

- * large of png_color.  This lets grayscale images be treated as

- * paletted.  Most useful for gamma correction and simplification

- * of code.

- */

-void PNGAPI

-png_build_grayscale_palette(int bit_depth, png_colorp palette)

-{

-   int num_palette;

-   int color_inc;

-   int i;

-   int v;

-

-   png_debug(1, "in png_do_build_grayscale_palette");

-

-   if (palette == NULL)

-      return;

-

-   switch (bit_depth)

-   {

-      case 1:

-         num_palette = 2;

-         color_inc = 0xff;

-         break;

-

-      case 2:

-         num_palette = 4;

-         color_inc = 0x55;

-         break;

-

-      case 4:

-         num_palette = 16;

-         color_inc = 0x11;

-         break;

-

-      case 8:

-         num_palette = 256;

-         color_inc = 1;

-         break;

-

-      default:

-         num_palette = 0;

-         color_inc = 0;

-         break;

-   }

-

-   for (i = 0, v = 0; i < num_palette; i++, v += color_inc)

-   {

-      palette[i].red = (png_byte)v;

-      palette[i].green = (png_byte)v;

-      palette[i].blue = (png_byte)v;

-   }

-}

-

-/* This function is currently unused.  Do we really need it? */

-#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)

-void /* PRIVATE */

-png_correct_palette(png_structp png_ptr, png_colorp palette,

-   int num_palette)

-{

-   png_debug(1, "in png_correct_palette");

-

-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \

-    defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

-   if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))

-   {

-      png_color back, back_1;

-

-      if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)

-      {

-         back.red = png_ptr->gamma_table[png_ptr->background.red];

-         back.green = png_ptr->gamma_table[png_ptr->background.green];

-         back.blue = png_ptr->gamma_table[png_ptr->background.blue];

-

-         back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];

-         back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];

-         back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];

-      }

-      else

-      {

-         double g;

-

-         g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);

-

-         if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||

-             fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)

-         {

-            back.red = png_ptr->background.red;

-            back.green = png_ptr->background.green;

-            back.blue = png_ptr->background.blue;

-         }

-         else

-         {

-            back.red =

-               (png_byte)(pow((double)png_ptr->background.red/255, g) *

-                255.0 + 0.5);

-            back.green =

-               (png_byte)(pow((double)png_ptr->background.green/255, g) *

-                255.0 + 0.5);

-            back.blue =

-               (png_byte)(pow((double)png_ptr->background.blue/255, g) *

-                255.0 + 0.5);

-         }

-

-         g = 1.0 / png_ptr->background_gamma;

-

-         back_1.red =

-            (png_byte)(pow((double)png_ptr->background.red/255, g) *

-             255.0 + 0.5);

-         back_1.green =

-            (png_byte)(pow((double)png_ptr->background.green/255, g) *

-             255.0 + 0.5);

-         back_1.blue =

-            (png_byte)(pow((double)png_ptr->background.blue/255, g) *

-             255.0 + 0.5);

-      }

-

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_uint_32 i;

-

-         for (i = 0; i < (png_uint_32)num_palette; i++)

-         {

-            if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)

-            {

-               palette[i] = back;

-            }

-            else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)

-            {

-               png_byte v, w;

-

-               v = png_ptr->gamma_to_1[png_ptr->palette[i].red];

-               png_composite(w, v, png_ptr->trans[i], back_1.red);

-               palette[i].red = png_ptr->gamma_from_1[w];

-

-               v = png_ptr->gamma_to_1[png_ptr->palette[i].green];

-               png_composite(w, v, png_ptr->trans[i], back_1.green);

-               palette[i].green = png_ptr->gamma_from_1[w];

-

-               v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];

-               png_composite(w, v, png_ptr->trans[i], back_1.blue);

-               palette[i].blue = png_ptr->gamma_from_1[w];

-            }

-            else

-            {

-               palette[i].red = png_ptr->gamma_table[palette[i].red];

-               palette[i].green = png_ptr->gamma_table[palette[i].green];

-               palette[i].blue = png_ptr->gamma_table[palette[i].blue];

-            }

-         }

-      }

-      else

-      {

-         int i;

-

-         for (i = 0; i < num_palette; i++)

-         {

-            if (palette[i].red == (png_byte)png_ptr->trans_values.gray)

-            {

-               palette[i] = back;

-            }

-            else

-            {

-               palette[i].red = png_ptr->gamma_table[palette[i].red];

-               palette[i].green = png_ptr->gamma_table[palette[i].green];

-               palette[i].blue = png_ptr->gamma_table[palette[i].blue];

-            }

-         }

-      }

-   }

-   else

-#endif

-#ifdef PNG_READ_GAMMA_SUPPORTED

-   if (png_ptr->transformations & PNG_GAMMA)

-   {

-      int i;

-

-      for (i = 0; i < num_palette; i++)

-      {

-         palette[i].red = png_ptr->gamma_table[palette[i].red];

-         palette[i].green = png_ptr->gamma_table[palette[i].green];

-         palette[i].blue = png_ptr->gamma_table[palette[i].blue];

-      }

-   }

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   else

-#endif

-#endif

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-   if (png_ptr->transformations & PNG_BACKGROUND)

-   {

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_color back;

-

-         back.red   = (png_byte)png_ptr->background.red;

-         back.green = (png_byte)png_ptr->background.green;

-         back.blue  = (png_byte)png_ptr->background.blue;

-

-         for (i = 0; i < (int)png_ptr->num_trans; i++)

-         {

-            if (png_ptr->trans[i] == 0)

-            {

-               palette[i].red = back.red;

-               palette[i].green = back.green;

-               palette[i].blue = back.blue;

-            }

-            else if (png_ptr->trans[i] != 0xff)

-            {

-               png_composite(palette[i].red, png_ptr->palette[i].red,

-                  png_ptr->trans[i], back.red);

-               png_composite(palette[i].green, png_ptr->palette[i].green,

-                  png_ptr->trans[i], back.green);

-               png_composite(palette[i].blue, png_ptr->palette[i].blue,

-                  png_ptr->trans[i], back.blue);

-            }

-         }

-      }

-      else /* Assume grayscale palette (what else could it be?) */

-      {

-         int i;

-

-         for (i = 0; i < num_palette; i++)

-         {

-            if (i == (png_byte)png_ptr->trans_values.gray)

-            {

-               palette[i].red = (png_byte)png_ptr->background.red;

-               palette[i].green = (png_byte)png_ptr->background.green;

-               palette[i].blue = (png_byte)png_ptr->background.blue;

-            }

-         }

-      }

-   }

-#endif

-}

-#endif

-

-#ifdef PNG_READ_BACKGROUND_SUPPORTED

-/* Replace any alpha or transparency with the supplied background color.

- * "background" is already in the screen gamma, while "background_1" is

- * at a gamma of 1.0.  Paletted files have already been taken care of.

- */

-void /* PRIVATE */

-png_do_background(png_row_infop row_info, png_bytep row,

-   png_color_16p trans_values, png_color_16p background

-#ifdef PNG_READ_GAMMA_SUPPORTED

-   , png_color_16p background_1,

-   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

-   png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

-   png_uint_16pp gamma_16_to_1, int gamma_shift

-#endif

-   )

-{

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-   int shift;

-

-   png_debug(1, "in png_do_background");

-

-   if (background != NULL &&

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-      (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||

-      (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))

-   {

-      switch (row_info->color_type)

-      {

-         case PNG_COLOR_TYPE_GRAY:

-         {

-            switch (row_info->bit_depth)

-            {

-               case 1:

-               {

-                  sp = row;

-                  shift = 7;

-                  for (i = 0; i < row_width; i++)

-                  {

-                     if ((png_uint_16)((*sp >> shift) & 0x01)

-                        == trans_values->gray)

-                     {

-                        *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

-                        *sp |= (png_byte)(background->gray << shift);

-                     }

-                     if (!shift)

-                     {

-                        shift = 7;

-                        sp++;

-                     }

-                     else

-                        shift--;

-                  }

-                  break;

-               }

-

-               case 2:

-               {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_table != NULL)

-                  {

-                     sp = row;

-                     shift = 6;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x03)

-                            == trans_values->gray)

-                        {

-                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

-                        }

-                        else

-                        {

-                           png_byte p = (png_byte)((*sp >> shift) & 0x03);

-                           png_byte g = (png_byte)((gamma_table [p | (p << 2) |

-                               (p << 4) | (p << 6)] >> 6) & 0x03);

-                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                           *sp |= (png_byte)(g << shift);

-                        }

-                        if (!shift)

-                        {

-                           shift = 6;

-                           sp++;

-                        }

-                        else

-                           shift -= 2;

-                     }

-                  }

-                  else

-#endif

-                  {

-                     sp = row;

-                     shift = 6;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x03)

-                            == trans_values->gray)

-                        {

-                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

-                        }

-                        if (!shift)

-                        {

-                           shift = 6;

-                           sp++;

-                        }

-                        else

-                           shift -= 2;

-                     }

-                  }

-                  break;

-               }

-

-               case 4:

-               {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_table != NULL)

-                  {

-                     sp = row;

-                     shift = 4;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x0f)

-                            == trans_values->gray)

-                        {

-                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

-                        }

-                        else

-                        {

-                           png_byte p = (png_byte)((*sp >> shift) & 0x0f);

-                           png_byte g = (png_byte)((gamma_table[p |

-                             (p << 4)] >> 4) & 0x0f);

-                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                           *sp |= (png_byte)(g << shift);

-                        }

-                        if (!shift)

-                        {

-                           shift = 4;

-                           sp++;

-                        }

-                        else

-                           shift -= 4;

-                     }

-                  }

-                  else

-#endif

-                  {

-                     sp = row;

-                     shift = 4;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x0f)

-                            == trans_values->gray)

-                        {

-                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

-                        }

-                        if (!shift)

-                        {

-                           shift = 4;

-                           sp++;

-                        }

-                        else

-                           shift -= 4;

-                     }

-                  }

-                  break;

-               }

-

-               case 8:

-               {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_table != NULL)

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp++)

-                     {

-                        if (*sp == trans_values->gray)

-                        {

-                           *sp = (png_byte)background->gray;

-                        }

-                        else

-                        {

-                           *sp = gamma_table[*sp];

-                        }

-                     }

-                  }

-                  else

-#endif

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp++)

-                     {

-                        if (*sp == trans_values->gray)

-                        {

-                           *sp = (png_byte)background->gray;

-                        }

-                     }

-                  }

-                  break;

-               }

-

-               case 16:

-               {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_16 != NULL)

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp += 2)

-                     {

-                        png_uint_16 v;

-

-                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        if (v == trans_values->gray)

-                        {

-                           /* Background is already in screen gamma */

-                           *sp = (png_byte)((background->gray >> 8) & 0xff);

-                           *(sp + 1) = (png_byte)(background->gray & 0xff);

-                        }

-                        else

-                        {

-                           v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                           *sp = (png_byte)((v >> 8) & 0xff);

-                           *(sp + 1) = (png_byte)(v & 0xff);

-                        }

-                     }

-                  }

-                  else

-#endif

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp += 2)

-                     {

-                        png_uint_16 v;

-

-                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        if (v == trans_values->gray)

-                        {

-                           *sp = (png_byte)((background->gray >> 8) & 0xff);

-                           *(sp + 1) = (png_byte)(background->gray & 0xff);

-                        }

-                     }

-                  }

-                  break;

-               }

-            }

-            break;

-         }

-

-         case PNG_COLOR_TYPE_RGB:

-         {

-            if (row_info->bit_depth == 8)

-            {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_table != NULL)

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 3)

-                  {

-                     if (*sp == trans_values->red &&

-                        *(sp + 1) == trans_values->green &&

-                        *(sp + 2) == trans_values->blue)

-                     {

-                        *sp = (png_byte)background->red;

-                        *(sp + 1) = (png_byte)background->green;

-                        *(sp + 2) = (png_byte)background->blue;

-                     }

-                     else

-                     {

-                        *sp = gamma_table[*sp];

-                        *(sp + 1) = gamma_table[*(sp + 1)];

-                        *(sp + 2) = gamma_table[*(sp + 2)];

-                     }

-                  }

-               }

-               else

-#endif

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 3)

-                  {

-                     if (*sp == trans_values->red &&

-                        *(sp + 1) == trans_values->green &&

-                        *(sp + 2) == trans_values->blue)

-                     {

-                        *sp = (png_byte)background->red;

-                        *(sp + 1) = (png_byte)background->green;

-                        *(sp + 2) = (png_byte)background->blue;

-                     }

-                  }

-               }

-            }

-            else /* if (row_info->bit_depth == 16) */

-            {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_16 != NULL)

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 6)

-                  {

-                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));

-                     if (r == trans_values->red && g == trans_values->green &&

-                        b == trans_values->blue)

-                     {

-                        /* Background is already in screen gamma */

-                        *sp = (png_byte)((background->red >> 8) & 0xff);

-                        *(sp + 1) = (png_byte)(background->red & 0xff);

-                        *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);

-                        *(sp + 3) = (png_byte)(background->green & 0xff);

-                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(sp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                     else

-                     {

-                        png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                        *sp = (png_byte)((v >> 8) & 0xff);

-                        *(sp + 1) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

-                        *(sp + 2) = (png_byte)((v >> 8) & 0xff);

-                        *(sp + 3) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

-                        *(sp + 4) = (png_byte)((v >> 8) & 0xff);

-                        *(sp + 5) = (png_byte)(v & 0xff);

-                     }

-                  }

-               }

-               else

-#endif

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 6)

-                  {

-                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));

-                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));

-

-                     if (r == trans_values->red && g == trans_values->green &&

-                        b == trans_values->blue)

-                     {

-                        *sp = (png_byte)((background->red >> 8) & 0xff);

-                        *(sp + 1) = (png_byte)(background->red & 0xff);

-                        *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);

-                        *(sp + 3) = (png_byte)(background->green & 0xff);

-                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(sp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                  }

-               }

-            }

-            break;

-         }

-

-         case PNG_COLOR_TYPE_GRAY_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

-            {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&

-                   gamma_table != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 2, dp++)

-                  {

-                     png_uint_16 a = *(sp + 1);

-

-                     if (a == 0xff)

-                     {

-                        *dp = gamma_table[*sp];

-                     }

-                     else if (a == 0)

-                     {

-                        /* Background is already in screen gamma */

-                        *dp = (png_byte)background->gray;

-                     }

-                     else

-                     {

-                        png_byte v, w;

-

-                        v = gamma_to_1[*sp];

-                        png_composite(w, v, a, background_1->gray);

-                        *dp = gamma_from_1[w];

-                     }

-                  }

-               }

-               else

-#endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 2, dp++)

-                  {

-                     png_byte a = *(sp + 1);

-

-                     if (a == 0xff)

-                     {

-                        *dp = *sp;

-                     }

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                     else if (a == 0)

-                     {

-                        *dp = (png_byte)background->gray;

-                     }

-                     else

-                     {

-                        png_composite(*dp, *sp, a, background_1->gray);

-                     }

-#else

-                     *dp = (png_byte)background->gray;

-#endif

-                  }

-               }

-            }

-            else /* if (png_ptr->bit_depth == 16) */

-            {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&

-                   gamma_16_to_1 != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)

-                  {

-                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_uint_16 v;

-

-                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                     }

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                     else if (a == 0)

-#else

-                     else

-#endif

-                     {

-                        /* Background is already in screen gamma */

-                        *dp = (png_byte)((background->gray >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(background->gray & 0xff);

-                     }

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                     else

-                     {

-                        png_uint_16 g, v, w;

-

-                        g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

-                        png_composite_16(v, g, a, background_1->gray);

-                        w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];

-                        *dp = (png_byte)((w >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(w & 0xff);

-                     }

-#endif

-                  }

-               }

-               else

-#endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)

-                  {

-                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_memcpy(dp, sp, 2);

-                     }

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                     else if (a == 0)

-#else

-                     else

-#endif

-                     {

-                        *dp = (png_byte)((background->gray >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(background->gray & 0xff);

-                     }

-#ifdef PNG_READ_GAMMA_SUPPORTED

-                     else

-                     {

-                        png_uint_16 g, v;

-

-                        g = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        png_composite_16(v, g, a, background_1->gray);

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                     }

-#endif

-                  }

-               }

-            }

-            break;

-         }

-

-         case PNG_COLOR_TYPE_RGB_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

-            {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&

-                   gamma_table != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)

-                  {

-                     png_byte a = *(sp + 3);

-

-                     if (a == 0xff)

-                     {

-                        *dp = gamma_table[*sp];

-                        *(dp + 1) = gamma_table[*(sp + 1)];

-                        *(dp + 2) = gamma_table[*(sp + 2)];

-                     }

-                     else if (a == 0)

-                     {

-                        /* Background is already in screen gamma */

-                        *dp = (png_byte)background->red;

-                        *(dp + 1) = (png_byte)background->green;

-                        *(dp + 2) = (png_byte)background->blue;

-                     }

-                     else

-                     {

-                        png_byte v, w;

-

-                        v = gamma_to_1[*sp];

-                        png_composite(w, v, a, background_1->red);

-                        *dp = gamma_from_1[w];

-                        v = gamma_to_1[*(sp + 1)];

-                        png_composite(w, v, a, background_1->green);

-                        *(dp + 1) = gamma_from_1[w];

-                        v = gamma_to_1[*(sp + 2)];

-                        png_composite(w, v, a, background_1->blue);

-                        *(dp + 2) = gamma_from_1[w];

-                     }

-                  }

-               }

-               else

-#endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)

-                  {

-                     png_byte a = *(sp + 3);

-

-                     if (a == 0xff)

-                     {

-                        *dp = *sp;

-                        *(dp + 1) = *(sp + 1);

-                        *(dp + 2) = *(sp + 2);

-                     }

-                     else if (a == 0)

-                     {

-                        *dp = (png_byte)background->red;

-                        *(dp + 1) = (png_byte)background->green;

-                        *(dp + 2) = (png_byte)background->blue;

-                     }

-                     else

-                     {

-                        png_composite(*dp, *sp, a, background->red);

-                        png_composite(*(dp + 1), *(sp + 1), a,

-                           background->green);

-                        png_composite(*(dp + 2), *(sp + 2), a,

-                           background->blue);

-                     }

-                  }

-               }

-            }

-            else /* if (row_info->bit_depth == 16) */

-            {

-#ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&

-                   gamma_16_to_1 != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)

-                  {

-                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

-                         << 8) + (png_uint_16)(*(sp + 7)));

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_uint_16 v;

-

-                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

-                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

-                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(v & 0xff);

-                     }

-                     else if (a == 0)

-                     {

-                        /* Background is already in screen gamma */

-                        *dp = (png_byte)((background->red >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(background->red & 0xff);

-                        *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(background->green & 0xff);

-                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                     else

-                     {

-                        png_uint_16 v, w, x;

-

-                        v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

-                        png_composite_16(w, v, a, background_1->red);

-                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

-                        *dp = (png_byte)((x >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(x & 0xff);

-                        v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];

-                        png_composite_16(w, v, a, background_1->green);

-                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

-                        *(dp + 2) = (png_byte)((x >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(x & 0xff);

-                        v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];

-                        png_composite_16(w, v, a, background_1->blue);

-                        x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];

-                        *(dp + 4) = (png_byte)((x >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(x & 0xff);

-                     }

-                  }

-               }

-               else

-#endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)

-                  {

-                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

-                        << 8) + (png_uint_16)(*(sp + 7)));

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_memcpy(dp, sp, 6);

-                     }

-                     else if (a == 0)

-                     {

-                        *dp = (png_byte)((background->red >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(background->red & 0xff);

-                        *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(background->green & 0xff);

-                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                     else

-                     {

-                        png_uint_16 v;

-

-                        png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)

-                            + *(sp + 3));

-                        png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)

-                            + *(sp + 5));

-

-                        png_composite_16(v, r, a, background->red);

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                        png_composite_16(v, g, a, background->green);

-                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(v & 0xff);

-                        png_composite_16(v, b, a, background->blue);

-                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(v & 0xff);

-                     }

-                  }

-               }

-            }

-            break;

-         }

-      }

-

-      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

-      {

-         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

-         row_info->channels--;

-         row_info->pixel_depth = (png_byte)(row_info->channels *

-            row_info->bit_depth);

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-   }

-}

-#endif

-

-#ifdef PNG_READ_GAMMA_SUPPORTED

-/* Gamma correct the image, avoiding the alpha channel.  Make sure

- * you do this after you deal with the transparency issue on grayscale

- * or RGB images. If your bit depth is 8, use gamma_table, if it

- * is 16, use gamma_16_table and gamma_shift.  Build these with

- * build_gamma_table().

- */

-void /* PRIVATE */

-png_do_gamma(png_row_infop row_info, png_bytep row,

-   png_bytep gamma_table, png_uint_16pp gamma_16_table,

-   int gamma_shift)

-{

-   png_bytep sp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-

-   png_debug(1, "in png_do_gamma");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-       ((row_info->bit_depth <= 8 && gamma_table != NULL) ||

-        (row_info->bit_depth == 16 && gamma_16_table != NULL)))

-   {

-      switch (row_info->color_type)

-      {

-         case PNG_COLOR_TYPE_RGB:

-         {

-            if (row_info->bit_depth == 8)

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-               }

-            }

-            else /* if (row_info->bit_depth == 16) */

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v;

-

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-               }

-            }

-            break;

-         }

-

-         case PNG_COLOR_TYPE_RGB_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  sp++;

-               }

-            }

-            else /* if (row_info->bit_depth == 16) */

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 4;

-               }

-            }

-            break;

-         }

-

-         case PNG_COLOR_TYPE_GRAY_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp += 2;

-               }

-            }

-            else /* if (row_info->bit_depth == 16) */

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 4;

-               }

-            }

-            break;

-         }

-

-         case PNG_COLOR_TYPE_GRAY:

-         {

-            if (row_info->bit_depth == 2)

-            {

-               sp = row;

-               for (i = 0; i < row_width; i += 4)

-               {

-                  int a = *sp & 0xc0;

-                  int b = *sp & 0x30;

-                  int c = *sp & 0x0c;

-                  int d = *sp & 0x03;

-

-                  *sp = (png_byte)(

-                        ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)])   ) & 0xc0)|

-                        ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|

-                        ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|

-                        ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));

-                  sp++;

-               }

-            }

-

-            if (row_info->bit_depth == 4)

-            {

-               sp = row;

-               for (i = 0; i < row_width; i += 2)

-               {

-                  int msb = *sp & 0xf0;

-                  int lsb = *sp & 0x0f;

-

-                  *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)

-                          | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));

-                  sp++;

-               }

-            }

-

-            else if (row_info->bit_depth == 8)

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp++;

-               }

-            }

-

-            else if (row_info->bit_depth == 16)

-            {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-               }

-            }

-            break;

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-/* Expands a palette row to an RGB or RGBA row depending

- * upon whether you supply trans and num_trans.

- */

-void /* PRIVATE */

-png_do_expand_palette(png_row_infop row_info, png_bytep row,

-   png_colorp palette, png_bytep trans, int num_trans)

-{

-   int shift, value;

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-

-   png_debug(1, "in png_do_expand_palette");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-       row_info->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (row_info->bit_depth < 8)

-      {

-         switch (row_info->bit_depth)

-         {

-            case 1:

-            {

-               sp = row + (png_size_t)((row_width - 1) >> 3);

-               dp = row + (png_size_t)row_width - 1;

-               shift = 7 - (int)((row_width + 7) & 0x07);

-               for (i = 0; i < row_width; i++)

-               {

-                  if ((*sp >> shift) & 0x01)

-                     *dp = 1;

-                  else

-                     *dp = 0;

-                  if (shift == 7)

-                  {

-                     shift = 0;

-                     sp--;

-                  }

-                  else

-                     shift++;

-

-                  dp--;

-               }

-               break;

-            }

-

-            case 2:

-            {

-               sp = row + (png_size_t)((row_width - 1) >> 2);

-               dp = row + (png_size_t)row_width - 1;

-               shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

-               for (i = 0; i < row_width; i++)

-               {

-                  value = (*sp >> shift) & 0x03;

-                  *dp = (png_byte)value;

-                  if (shift == 6)

-                  {

-                     shift = 0;

-                     sp--;

-                  }

-                  else

-                     shift += 2;

-

-                  dp--;

-               }

-               break;

-            }

-

-            case 4:

-            {

-               sp = row + (png_size_t)((row_width - 1) >> 1);

-               dp = row + (png_size_t)row_width - 1;

-               shift = (int)((row_width & 0x01) << 2);

-               for (i = 0; i < row_width; i++)

-               {

-                  value = (*sp >> shift) & 0x0f;

-                  *dp = (png_byte)value;

-                  if (shift == 4)

-                  {

-                     shift = 0;

-                     sp--;

-                  }

-                  else

-                     shift += 4;

-

-                  dp--;

-               }

-               break;

-            }

-         }

-         row_info->bit_depth = 8;

-         row_info->pixel_depth = 8;

-         row_info->rowbytes = row_width;

-      }

-      switch (row_info->bit_depth)

-      {

-         case 8:

-         {

-            if (trans != NULL)

-            {

-               sp = row + (png_size_t)row_width - 1;

-               dp = row + (png_size_t)(row_width << 2) - 1;

-

-               for (i = 0; i < row_width; i++)

-               {

-                  if ((int)(*sp) >= num_trans)

-                     *dp-- = 0xff;

-                  else

-                     *dp-- = trans[*sp];

-                  *dp-- = palette[*sp].blue;

-                  *dp-- = palette[*sp].green;

-                  *dp-- = palette[*sp].red;

-                  sp--;

-               }

-               row_info->bit_depth = 8;

-               row_info->pixel_depth = 32;

-               row_info->rowbytes = row_width * 4;

-               row_info->color_type = 6;

-               row_info->channels = 4;

-            }

-            else

-            {

-               sp = row + (png_size_t)row_width - 1;

-               dp = row + (png_size_t)(row_width * 3) - 1;

-

-               for (i = 0; i < row_width; i++)

-               {

-                  *dp-- = palette[*sp].blue;

-                  *dp-- = palette[*sp].green;

-                  *dp-- = palette[*sp].red;

-                  sp--;

-               }

-

-               row_info->bit_depth = 8;

-               row_info->pixel_depth = 24;

-               row_info->rowbytes = row_width * 3;

-               row_info->color_type = 2;

-               row_info->channels = 3;

-            }

-            break;

-         }

-      }

-   }

-}

-

-/* If the bit depth < 8, it is expanded to 8.  Also, if the already

- * expanded transparency value is supplied, an alpha channel is built.

- */

-void /* PRIVATE */

-png_do_expand(png_row_infop row_info, png_bytep row,

-   png_color_16p trans_value)

-{

-   int shift, value;

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-

-   png_debug(1, "in png_do_expand");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL)

-#endif

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);

-

-         if (row_info->bit_depth < 8)

-         {

-            switch (row_info->bit_depth)

-            {

-               case 1:

-               {

-                  gray = (png_uint_16)((gray&0x01)*0xff);

-                  sp = row + (png_size_t)((row_width - 1) >> 3);

-                  dp = row + (png_size_t)row_width - 1;

-                  shift = 7 - (int)((row_width + 7) & 0x07);

-                  for (i = 0; i < row_width; i++)

-                  {

-                     if ((*sp >> shift) & 0x01)

-                        *dp = 0xff;

-                     else

-                        *dp = 0;

-                     if (shift == 7)

-                     {

-                        shift = 0;

-                        sp--;

-                     }

-                     else

-                        shift++;

-

-                     dp--;

-                  }

-                  break;

-               }

-

-               case 2:

-               {

-                  gray = (png_uint_16)((gray&0x03)*0x55);

-                  sp = row + (png_size_t)((row_width - 1) >> 2);

-                  dp = row + (png_size_t)row_width - 1;

-                  shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

-                  for (i = 0; i < row_width; i++)

-                  {

-                     value = (*sp >> shift) & 0x03;

-                     *dp = (png_byte)(value | (value << 2) | (value << 4) |

-                        (value << 6));

-                     if (shift == 6)

-                     {

-                        shift = 0;

-                        sp--;

-                     }

-                     else

-                        shift += 2;

-

-                     dp--;

-                  }

-                  break;

-               }

-

-               case 4:

-               {

-                  gray = (png_uint_16)((gray&0x0f)*0x11);

-                  sp = row + (png_size_t)((row_width - 1) >> 1);

-                  dp = row + (png_size_t)row_width - 1;

-                  shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);

-                  for (i = 0; i < row_width; i++)

-                  {

-                     value = (*sp >> shift) & 0x0f;

-                     *dp = (png_byte)(value | (value << 4));

-                     if (shift == 4)

-                     {

-                        shift = 0;

-                        sp--;

-                     }

-                     else

-                        shift = 4;

-

-                     dp--;

-                  }

-                  break;

-               }

-            }

-

-            row_info->bit_depth = 8;

-            row_info->pixel_depth = 8;

-            row_info->rowbytes = row_width;

-         }

-

-         if (trans_value != NULL)

-         {

-            if (row_info->bit_depth == 8)

-            {

-               gray = gray & 0xff;

-               sp = row + (png_size_t)row_width - 1;

-               dp = row + (png_size_t)(row_width << 1) - 1;

-               for (i = 0; i < row_width; i++)

-               {

-                  if (*sp == gray)

-                     *dp-- = 0;

-                  else

-                     *dp-- = 0xff;

-                  *dp-- = *sp--;

-               }

-            }

-

-            else if (row_info->bit_depth == 16)

-            {

-               png_byte gray_high = (gray >> 8) & 0xff;

-               png_byte gray_low = gray & 0xff;

-               sp = row + row_info->rowbytes - 1;

-               dp = row + (row_info->rowbytes << 1) - 1;

-               for (i = 0; i < row_width; i++)

-               {

-                  if (*(sp - 1) == gray_high && *(sp) == gray_low)

-                  {

-                     *dp-- = 0;

-                     *dp-- = 0;

-                  }

-                  else

-                  {

-                     *dp-- = 0xff;

-                     *dp-- = 0xff;

-                  }

-                  *dp-- = *sp--;

-                  *dp-- = *sp--;

-               }

-            }

-

-            row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;

-            row_info->channels = 2;

-            row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);

-            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

-               row_width);

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            png_byte red = trans_value->red & 0xff;

-            png_byte green = trans_value->green & 0xff;

-            png_byte blue = trans_value->blue & 0xff;

-            sp = row + (png_size_t)row_info->rowbytes - 1;

-            dp = row + (png_size_t)(row_width << 2) - 1;

-            for (i = 0; i < row_width; i++)

-            {

-               if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)

-                  *dp-- = 0;

-               else

-                  *dp-- = 0xff;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-            }

-         }

-         else if (row_info->bit_depth == 16)

-         {

-            png_byte red_high = (trans_value->red >> 8) & 0xff;

-            png_byte green_high = (trans_value->green >> 8) & 0xff;

-            png_byte blue_high = (trans_value->blue >> 8) & 0xff;

-            png_byte red_low = trans_value->red & 0xff;

-            png_byte green_low = trans_value->green & 0xff;

-            png_byte blue_low = trans_value->blue & 0xff;

-            sp = row + row_info->rowbytes - 1;

-            dp = row + (png_size_t)(row_width << 3) - 1;

-            for (i = 0; i < row_width; i++)

-            {

-               if (*(sp - 5) == red_high &&

-                  *(sp - 4) == red_low &&

-                  *(sp - 3) == green_high &&

-                  *(sp - 2) == green_low &&

-                  *(sp - 1) == blue_high &&

-                  *(sp    ) == blue_low)

-               {

-                  *dp-- = 0;

-                  *dp-- = 0;

-               }

-               else

-               {

-                  *dp-- = 0xff;

-                  *dp-- = 0xff;

-               }

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-            }

-         }

-         row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

-         row_info->channels = 4;

-         row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-   }

-}

-#endif

-

-#ifdef PNG_READ_DITHER_SUPPORTED

-void /* PRIVATE */

-png_do_dither(png_row_infop row_info, png_bytep row,

-    png_bytep palette_lookup, png_bytep dither_lookup)

-{

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-

-   png_debug(1, "in png_do_dither");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL)

-#endif

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB &&

-         palette_lookup && row_info->bit_depth == 8)

-      {

-         int r, g, b, p;

-         sp = row;

-         dp = row;

-         for (i = 0; i < row_width; i++)

-         {

-            r = *sp++;

-            g = *sp++;

-            b = *sp++;

-

-            /* This looks real messy, but the compiler will reduce

-             * it down to a reasonable formula.  For example, with

-             * 5 bits per color, we get:

-             * p = (((r >> 3) & 0x1f) << 10) |

-             *    (((g >> 3) & 0x1f) << 5) |

-             *    ((b >> 3) & 0x1f);

-             */

-            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

-               ((1 << PNG_DITHER_RED_BITS) - 1)) <<

-               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

-               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

-               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

-               (PNG_DITHER_BLUE_BITS)) |

-               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

-               ((1 << PNG_DITHER_BLUE_BITS) - 1));

-

-            *dp++ = palette_lookup[p];

-         }

-         row_info->color_type = PNG_COLOR_TYPE_PALETTE;

-         row_info->channels = 1;

-         row_info->pixel_depth = row_info->bit_depth;

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&

-         palette_lookup != NULL && row_info->bit_depth == 8)

-      {

-         int r, g, b, p;

-         sp = row;

-         dp = row;

-         for (i = 0; i < row_width; i++)

-         {

-            r = *sp++;

-            g = *sp++;

-            b = *sp++;

-            sp++;

-

-            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

-               ((1 << PNG_DITHER_RED_BITS) - 1)) <<

-               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

-               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

-               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

-               (PNG_DITHER_BLUE_BITS)) |

-               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

-               ((1 << PNG_DITHER_BLUE_BITS) - 1));

-

-            *dp++ = palette_lookup[p];

-         }

-         row_info->color_type = PNG_COLOR_TYPE_PALETTE;

-         row_info->channels = 1;

-         row_info->pixel_depth = row_info->bit_depth;

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&

-         dither_lookup && row_info->bit_depth == 8)

-      {

-         sp = row;

-         for (i = 0; i < row_width; i++, sp++)

-         {

-            *sp = dither_lookup[*sp];

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-#ifdef PNG_READ_GAMMA_SUPPORTED

-static PNG_CONST int png_gamma_shift[] =

-   {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};

-

-/* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit

- * tables, we don't make a full table if we are reducing to 8-bit in

- * the future.  Note also how the gamma_16 tables are segmented so that

- * we don't need to allocate > 64K chunks for a full 16-bit table.

- *

- * See the PNG extensions document for an integer algorithm for creating

- * the gamma tables.  Maybe we will implement that here someday.

- *

- * We should only reach this point if

- *

- *      the file_gamma is known (i.e., the gAMA or sRGB chunk is present,

- *      or the application has provided a file_gamma)

- *

- *   AND

- *      {

- *         the screen_gamma is known

- *      OR

- *

- *         RGB_to_gray transformation is being performed

- *      }

- *

- *   AND

- *      {

- *         the screen_gamma is different from the reciprocal of the

- *         file_gamma by more than the specified threshold

- *

- *      OR

- *

- *         a background color has been specified and the file_gamma

- *         and screen_gamma are not 1.0, within the specified threshold.

- *      }

- */

-

-void /* PRIVATE */

-png_build_gamma_table(png_structp png_ptr)

-{

-  png_debug(1, "in png_build_gamma_table");

-

-  if (png_ptr->bit_depth <= 8)

-  {

-     int i;

-     double g;

-

-     if (png_ptr->screen_gamma > .000001)

-        g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

-

-     else

-        g = 1.0;

-

-     png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,

-        (png_uint_32)256);

-

-     for (i = 0; i < 256; i++)

-     {

-        png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,

-           g) * 255.0 + .5);

-     }

-

-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \

-   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

-     if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))

-     {

-

-        g = 1.0 / (png_ptr->gamma);

-

-        png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,

-           (png_uint_32)256);

-

-        for (i = 0; i < 256; i++)

-        {

-           png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,

-              g) * 255.0 + .5);

-        }

-

-

-        png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,

-           (png_uint_32)256);

-

-        if (png_ptr->screen_gamma > 0.000001)

-           g = 1.0 / png_ptr->screen_gamma;

-

-        else

-           g = png_ptr->gamma;   /* Probably doing rgb_to_gray */

-

-        for (i = 0; i < 256; i++)

-        {

-           png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,

-              g) * 255.0 + .5);

-

-        }

-     }

-#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */

-  }

-  else

-  {

-     double g;

-     int i, j, shift, num;

-     int sig_bit;

-     png_uint_32 ig;

-

-     if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

-     {

-        sig_bit = (int)png_ptr->sig_bit.red;

-

-        if ((int)png_ptr->sig_bit.green > sig_bit)

-           sig_bit = png_ptr->sig_bit.green;

-

-        if ((int)png_ptr->sig_bit.blue > sig_bit)

-           sig_bit = png_ptr->sig_bit.blue;

-     }

-     else

-     {

-        sig_bit = (int)png_ptr->sig_bit.gray;

-     }

-

-     if (sig_bit > 0)

-        shift = 16 - sig_bit;

-

-     else

-        shift = 0;

-

-     if (png_ptr->transformations & PNG_16_TO_8)

-     {

-        if (shift < (16 - PNG_MAX_GAMMA_8))

-           shift = (16 - PNG_MAX_GAMMA_8);

-     }

-

-     if (shift > 8)

-        shift = 8;

-

-     if (shift < 0)

-        shift = 0;

-

-     png_ptr->gamma_shift = (png_byte)shift;

-

-     num = (1 << (8 - shift));

-

-     if (png_ptr->screen_gamma > .000001)

-        g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

-     else

-        g = 1.0;

-

-     png_ptr->gamma_16_table = (png_uint_16pp)png_calloc(png_ptr,

-        (png_uint_32)(num * png_sizeof(png_uint_16p)));

-

-     if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))

-     {

-        double fin, fout;

-        png_uint_32 last, max;

-

-        for (i = 0; i < num; i++)

-        {

-           png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

-              (png_uint_32)(256 * png_sizeof(png_uint_16)));

-        }

-

-        g = 1.0 / g;

-        last = 0;

-        for (i = 0; i < 256; i++)

-        {

-           fout = ((double)i + 0.5) / 256.0;

-           fin = pow(fout, g);

-           max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));

-           while (last <= max)

-           {

-              png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

-                 [(int)(last >> (8 - shift))] = (png_uint_16)(

-                 (png_uint_16)i | ((png_uint_16)i << 8));

-              last++;

-           }

-        }

-        while (last < ((png_uint_32)num << 8))

-        {

-           png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

-              [(int)(last >> (8 - shift))] = (png_uint_16)65535L;

-           last++;

-        }

-     }

-     else

-     {

-        for (i = 0; i < num; i++)

-        {

-           png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

-              (png_uint_32)(256 * png_sizeof(png_uint_16)));

-

-           ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);

-

-           for (j = 0; j < 256; j++)

-           {

-              png_ptr->gamma_16_table[i][j] =

-                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

-                    65535.0, g) * 65535.0 + .5);

-           }

-        }

-     }

-

-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \

-   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

-     if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))

-     {

-

-        g = 1.0 / (png_ptr->gamma);

-

-        png_ptr->gamma_16_to_1 = (png_uint_16pp)png_calloc(png_ptr,

-           (png_uint_32)(num * png_sizeof(png_uint_16p )));

-

-        for (i = 0; i < num; i++)

-        {

-           png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,

-              (png_uint_32)(256 * png_sizeof(png_uint_16)));

-

-           ig = (((png_uint_32)i *

-              (png_uint_32)png_gamma_shift[shift]) >> 4);

-           for (j = 0; j < 256; j++)

-           {

-              png_ptr->gamma_16_to_1[i][j] =

-                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

-                    65535.0, g) * 65535.0 + .5);

-           }

-        }

-

-        if (png_ptr->screen_gamma > 0.000001)

-           g = 1.0 / png_ptr->screen_gamma;

-

-        else

-           g = png_ptr->gamma;   /* Probably doing rgb_to_gray */

-

-        png_ptr->gamma_16_from_1 = (png_uint_16pp)png_calloc(png_ptr,

-           (png_uint_32)(num * png_sizeof(png_uint_16p)));

-

-        for (i = 0; i < num; i++)

-        {

-           png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,

-              (png_uint_32)(256 * png_sizeof(png_uint_16)));

-

-           ig = (((png_uint_32)i *

-              (png_uint_32)png_gamma_shift[shift]) >> 4);

-

-           for (j = 0; j < 256; j++)

-           {

-              png_ptr->gamma_16_from_1[i][j] =

-                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

-                    65535.0, g) * 65535.0 + .5);

-           }

-        }

-     }

-#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */

-  }

-}

-#endif

-/* To do: install integer version of png_build_gamma_table here */

-#endif

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-/* Undoes intrapixel differencing  */

-void /* PRIVATE */

-png_do_read_intrapixel(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_read_intrapixel");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-       (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      int bytes_per_pixel;

-      png_uint_32 row_width = row_info->width;

-      if (row_info->bit_depth == 8)

-      {

-         png_bytep rp;

-         png_uint_32 i;

-

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-            bytes_per_pixel = 3;

-

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-            bytes_per_pixel = 4;

-

-         else

-            return;

-

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);

-            *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         png_bytep rp;

-         png_uint_32 i;

-

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-            bytes_per_pixel = 6;

-

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-            bytes_per_pixel = 8;

-

-         else

-            return;

-

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);

-            png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);

-            png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);

-            png_uint_32 red  = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);

-            png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);

-            *(rp  ) = (png_byte)((red >> 8) & 0xff);

-            *(rp+1) = (png_byte)(red & 0xff);

-            *(rp+4) = (png_byte)((blue >> 8) & 0xff);

-            *(rp+5) = (png_byte)(blue & 0xff);

-         }

-      }

-   }

-}

-#endif /* PNG_MNG_FEATURES_SUPPORTED */

-#endif /* PNG_READ_SUPPORTED */

+
+/* pngrtran.c - transforms the data in a row for PNG readers
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file contains functions optionally called by an application
+ * in order to tell libpng how to handle data when reading a PNG.
+ * Transformations that are used in both reading and writing are
+ * in pngtrans.c.
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_READ_SUPPORTED
+#include "pngpriv.h"
+
+/* Set the action on getting a CRC error for an ancillary or critical chunk. */
+void PNGAPI
+png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
+{
+   png_debug(1, "in png_set_crc_action");
+ 
+   if (png_ptr == NULL)
+      return;
+
+   /* Tell libpng how we react to CRC errors in critical chunks */
+   switch (crit_action)
+   {
+      case PNG_CRC_NO_CHANGE:                        /* Leave setting as is */
+         break;
+
+      case PNG_CRC_WARN_USE:                               /* Warn/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
+         break;
+
+      case PNG_CRC_QUIET_USE:                             /* Quiet/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
+                           PNG_FLAG_CRC_CRITICAL_IGNORE;
+         break;
+
+      case PNG_CRC_WARN_DISCARD:    /* Not a valid action for critical data */
+         png_warning(png_ptr,
+            "Can't discard critical data on CRC error");
+      case PNG_CRC_ERROR_QUIT:                                /* Error/quit */
+
+      case PNG_CRC_DEFAULT:
+      default:
+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+         break;
+   }
+
+   /* Tell libpng how we react to CRC errors in ancillary chunks */
+   switch (ancil_action)
+   {
+      case PNG_CRC_NO_CHANGE:                       /* Leave setting as is */
+         break;
+
+      case PNG_CRC_WARN_USE:                              /* Warn/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
+         break;
+
+      case PNG_CRC_QUIET_USE:                            /* Quiet/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
+                           PNG_FLAG_CRC_ANCILLARY_NOWARN;
+         break;
+
+      case PNG_CRC_ERROR_QUIT:                               /* Error/quit */
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
+         break;
+
+      case PNG_CRC_WARN_DISCARD:                      /* Warn/discard data */
+
+      case PNG_CRC_DEFAULT:
+      default:
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         break;
+   }
+}
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
+    defined(PNG_FLOATING_POINT_SUPPORTED)
+/* Handle alpha and tRNS via a background color */
+void PNGAPI
+png_set_background(png_structp png_ptr,
+   png_color_16p background_color, int background_gamma_code,
+   int need_expand, double background_gamma)
+{
+   png_debug(1, "in png_set_background");
+ 
+   if (png_ptr == NULL)
+      return;
+   if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
+   {
+      png_warning(png_ptr, "Application must supply a known background gamma");
+      return;
+   }
+
+   png_ptr->transformations |= PNG_BACKGROUND;
+   png_memcpy(&(png_ptr->background), background_color,
+      png_sizeof(png_color_16));
+   png_ptr->background_gamma = (float)background_gamma;
+   png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
+   png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);
+}
+#endif
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+/* Strip 16 bit depth files to 8 bit depth */
+void PNGAPI
+png_set_strip_16(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_strip_16");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_16_TO_8;
+}
+#endif
+
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+void PNGAPI
+png_set_strip_alpha(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_strip_alpha");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
+}
+#endif
+
+#ifdef PNG_READ_DITHER_SUPPORTED
+/* Dither file to 8 bit.  Supply a palette, the current number
+ * of elements in the palette, the maximum number of elements
+ * allowed, and a histogram if possible.  If the current number
+ * of colors is greater then the maximum number, the palette will be
+ * modified to fit in the maximum number.  "full_dither" indicates
+ * whether we need a dithering cube set up for RGB images, or if we
+ * simply are reducing the number of colors in a paletted image.
+ */
+
+typedef struct png_dsort_struct
+{
+   struct png_dsort_struct FAR * next;
+   png_byte left;
+   png_byte right;
+} png_dsort;
+typedef png_dsort FAR *       png_dsortp;
+typedef png_dsort FAR * FAR * png_dsortpp;
+
+void PNGAPI
+png_set_dither(png_structp png_ptr, png_colorp palette,
+   int num_palette, int maximum_colors, png_uint_16p histogram,
+   int full_dither)
+{
+   png_debug(1, "in png_set_dither");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_DITHER;
+
+   if (!full_dither)
+   {
+      int i;
+
+      png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,
+         (png_uint_32)(num_palette * png_sizeof(png_byte)));
+      for (i = 0; i < num_palette; i++)
+         png_ptr->dither_index[i] = (png_byte)i;
+   }
+
+   if (num_palette > maximum_colors)
+   {
+      if (histogram != NULL)
+      {
+         /* This is easy enough, just throw out the least used colors.
+          * Perhaps not the best solution, but good enough.
+          */
+
+         int i;
+
+         /* Initialize an array to sort colors */
+         png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,
+            (png_uint_32)(num_palette * png_sizeof(png_byte)));
+
+         /* Initialize the dither_sort array */
+         for (i = 0; i < num_palette; i++)
+            png_ptr->dither_sort[i] = (png_byte)i;
+
+         /* Find the least used palette entries by starting a
+          * bubble sort, and running it until we have sorted
+          * out enough colors.  Note that we don't care about
+          * sorting all the colors, just finding which are
+          * least used.
+          */
+
+         for (i = num_palette - 1; i >= maximum_colors; i--)
+         {
+            int done; /* To stop early if the list is pre-sorted */
+            int j;
+
+            done = 1;
+            for (j = 0; j < i; j++)
+            {
+               if (histogram[png_ptr->dither_sort[j]]
+                   < histogram[png_ptr->dither_sort[j + 1]])
+               {
+                  png_byte t;
+
+                  t = png_ptr->dither_sort[j];
+                  png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];
+                  png_ptr->dither_sort[j + 1] = t;
+                  done = 0;
+               }
+            }
+            if (done)
+               break;
+         }
+
+         /* Swap the palette around, and set up a table, if necessary */
+         if (full_dither)
+         {
+            int j = num_palette;
+
+            /* Put all the useful colors within the max, but don't
+             * move the others.
+             */
+            for (i = 0; i < maximum_colors; i++)
+            {
+               if ((int)png_ptr->dither_sort[i] >= maximum_colors)
+               {
+                  do
+                     j--;
+                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);
+                  palette[i] = palette[j];
+               }
+            }
+         }
+         else
+         {
+            int j = num_palette;
+
+            /* Move all the used colors inside the max limit, and
+             * develop a translation table.
+             */
+            for (i = 0; i < maximum_colors; i++)
+            {
+               /* Only move the colors we need to */
+               if ((int)png_ptr->dither_sort[i] >= maximum_colors)
+               {
+                  png_color tmp_color;
+
+                  do
+                     j--;
+                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);
+
+                  tmp_color = palette[j];
+                  palette[j] = palette[i];
+                  palette[i] = tmp_color;
+                  /* Indicate where the color went */
+                  png_ptr->dither_index[j] = (png_byte)i;
+                  png_ptr->dither_index[i] = (png_byte)j;
+               }
+            }
+
+            /* Find closest color for those colors we are not using */
+            for (i = 0; i < num_palette; i++)
+            {
+               if ((int)png_ptr->dither_index[i] >= maximum_colors)
+               {
+                  int min_d, k, min_k, d_index;
+
+                  /* Find the closest color to one we threw out */
+                  d_index = png_ptr->dither_index[i];
+                  min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
+                  for (k = 1, min_k = 0; k < maximum_colors; k++)
+                  {
+                     int d;
+
+                     d = PNG_COLOR_DIST(palette[d_index], palette[k]);
+
+                     if (d < min_d)
+                     {
+                        min_d = d;
+                        min_k = k;
+                     }
+                  }
+                  /* Point to closest color */
+                  png_ptr->dither_index[i] = (png_byte)min_k;
+               }
+            }
+         }
+         png_free(png_ptr, png_ptr->dither_sort);
+         png_ptr->dither_sort = NULL;
+      }
+      else
+      {
+         /* This is much harder to do simply (and quickly).  Perhaps
+          * we need to go through a median cut routine, but those
+          * don't always behave themselves with only a few colors
+          * as input.  So we will just find the closest two colors,
+          * and throw out one of them (chosen somewhat randomly).
+          * [We don't understand this at all, so if someone wants to
+          *  work on improving it, be our guest - AED, GRP]
+          */
+         int i;
+         int max_d;
+         int num_new_palette;
+         png_dsortp t;
+         png_dsortpp hash;
+
+         t = NULL;
+
+         /* Initialize palette index arrays */
+         png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
+            (png_uint_32)(num_palette * png_sizeof(png_byte)));
+         png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
+            (png_uint_32)(num_palette * png_sizeof(png_byte)));
+
+         /* Initialize the sort array */
+         for (i = 0; i < num_palette; i++)
+         {
+            png_ptr->index_to_palette[i] = (png_byte)i;
+            png_ptr->palette_to_index[i] = (png_byte)i;
+         }
+
+         hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *
+            png_sizeof(png_dsortp)));
+
+         num_new_palette = num_palette;
+
+         /* Initial wild guess at how far apart the farthest pixel
+          * pair we will be eliminating will be.  Larger
+          * numbers mean more areas will be allocated, Smaller
+          * numbers run the risk of not saving enough data, and
+          * having to do this all over again.
+          *
+          * I have not done extensive checking on this number.
+          */
+         max_d = 96;
+
+         while (num_new_palette > maximum_colors)
+         {
+            for (i = 0; i < num_new_palette - 1; i++)
+            {
+               int j;
+
+               for (j = i + 1; j < num_new_palette; j++)
+               {
+                  int d;
+
+                  d = PNG_COLOR_DIST(palette[i], palette[j]);
+
+                  if (d <= max_d)
+                  {
+
+                     t = (png_dsortp)png_malloc_warn(png_ptr,
+                         (png_uint_32)(png_sizeof(png_dsort)));
+                     if (t == NULL)
+                         break;
+                     t->next = hash[d];
+                     t->left = (png_byte)i;
+                     t->right = (png_byte)j;
+                     hash[d] = t;
+                  }
+               }
+               if (t == NULL)
+                  break;
+            }
+
+            if (t != NULL)
+            for (i = 0; i <= max_d; i++)
+            {
+               if (hash[i] != NULL)
+               {
+                  png_dsortp p;
+
+                  for (p = hash[i]; p; p = p->next)
+                  {
+                     if ((int)png_ptr->index_to_palette[p->left]
+                        < num_new_palette &&
+                        (int)png_ptr->index_to_palette[p->right]
+                        < num_new_palette)
+                     {
+                        int j, next_j;
+
+                        if (num_new_palette & 0x01)
+                        {
+                           j = p->left;
+                           next_j = p->right;
+                        }
+                        else
+                        {
+                           j = p->right;
+                           next_j = p->left;
+                        }
+
+                        num_new_palette--;
+                        palette[png_ptr->index_to_palette[j]]
+                          = palette[num_new_palette];
+                        if (!full_dither)
+                        {
+                           int k;
+
+                           for (k = 0; k < num_palette; k++)
+                           {
+                              if (png_ptr->dither_index[k] ==
+                                 png_ptr->index_to_palette[j])
+                                 png_ptr->dither_index[k] =
+                                    png_ptr->index_to_palette[next_j];
+                              if ((int)png_ptr->dither_index[k] ==
+                                 num_new_palette)
+                                 png_ptr->dither_index[k] =
+                                    png_ptr->index_to_palette[j];
+                           }
+                        }
+
+                        png_ptr->index_to_palette[png_ptr->palette_to_index
+                           [num_new_palette]] = png_ptr->index_to_palette[j];
+                        png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
+                           = png_ptr->palette_to_index[num_new_palette];
+
+                        png_ptr->index_to_palette[j] = (png_byte)num_new_palette;
+                        png_ptr->palette_to_index[num_new_palette] = (png_byte)j;
+                     }
+                     if (num_new_palette <= maximum_colors)
+                        break;
+                  }
+                  if (num_new_palette <= maximum_colors)
+                     break;
+               }
+            }
+
+            for (i = 0; i < 769; i++)
+            {
+               if (hash[i] != NULL)
+               {
+                  png_dsortp p = hash[i];
+                  while (p)
+                  {
+                     t = p->next;
+                     png_free(png_ptr, p);
+                     p = t;
+                  }
+               }
+               hash[i] = 0;
+            }
+            max_d += 96;
+         }
+         png_free(png_ptr, hash);
+         png_free(png_ptr, png_ptr->palette_to_index);
+         png_free(png_ptr, png_ptr->index_to_palette);
+         png_ptr->palette_to_index = NULL;
+         png_ptr->index_to_palette = NULL;
+      }
+      num_palette = maximum_colors;
+   }
+   if (png_ptr->palette == NULL)
+   {
+      png_ptr->palette = palette;
+   }
+   png_ptr->num_palette = (png_uint_16)num_palette;
+
+   if (full_dither)
+   {
+      int i;
+      png_bytep distance;
+      int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
+         PNG_DITHER_BLUE_BITS;
+      int num_red = (1 << PNG_DITHER_RED_BITS);
+      int num_green = (1 << PNG_DITHER_GREEN_BITS);
+      int num_blue = (1 << PNG_DITHER_BLUE_BITS);
+      png_size_t num_entries = ((png_size_t)1 << total_bits);
+
+      png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr,
+         (png_uint_32)(num_entries * png_sizeof(png_byte)));
+
+      distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
+         png_sizeof(png_byte)));
+      png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
+
+      for (i = 0; i < num_palette; i++)
+      {
+         int ir, ig, ib;
+         int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
+         int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
+         int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
+
+         for (ir = 0; ir < num_red; ir++)
+         {
+            /* int dr = abs(ir - r); */
+            int dr = ((ir > r) ? ir - r : r - ir);
+            int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
+
+            for (ig = 0; ig < num_green; ig++)
+            {
+               /* int dg = abs(ig - g); */
+               int dg = ((ig > g) ? ig - g : g - ig);
+               int dt = dr + dg;
+               int dm = ((dr > dg) ? dr : dg);
+               int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);
+
+               for (ib = 0; ib < num_blue; ib++)
+               {
+                  int d_index = index_g | ib;
+                  /* int db = abs(ib - b); */
+                  int db = ((ib > b) ? ib - b : b - ib);
+                  int dmax = ((dm > db) ? dm : db);
+                  int d = dmax + dt + db;
+
+                  if (d < (int)distance[d_index])
+                  {
+                     distance[d_index] = (png_byte)d;
+                     png_ptr->palette_lookup[d_index] = (png_byte)i;
+                  }
+               }
+            }
+         }
+      }
+
+      png_free(png_ptr, distance);
+   }
+}
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+/* Transform the image from the file_gamma to the screen_gamma.  We
+ * only do transformations on images where the file_gamma and screen_gamma
+ * are not close reciprocals, otherwise it slows things down slightly, and
+ * also needlessly introduces small errors.
+ *
+ * We will turn off gamma transformation later if no semitransparent entries
+ * are present in the tRNS array for palette images.  We can't do it here
+ * because we don't necessarily have the tRNS chunk yet.
+ */
+void PNGAPI
+png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
+{
+   png_debug(1, "in png_set_gamma");
+
+   if (png_ptr == NULL)
+      return;
+
+   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_TYPE_PALETTE))
+     png_ptr->transformations |= PNG_GAMMA;
+   png_ptr->gamma = (float)file_gamma;
+   png_ptr->screen_gamma = (float)scrn_gamma;
+}
+#endif
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* Expand paletted images to RGB, expand grayscale images of
+ * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
+ * to alpha channels.
+ */
+void PNGAPI
+png_set_expand(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_expand");
+
+   if (png_ptr == NULL)
+      return;
+
+   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+
+/* GRR 19990627:  the following three functions currently are identical
+ *  to png_set_expand().  However, it is entirely reasonable that someone
+ *  might wish to expand an indexed image to RGB but *not* expand a single,
+ *  fully transparent palette entry to a full alpha channel--perhaps instead
+ *  convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace
+ *  the transparent color with a particular RGB value, or drop tRNS entirely.
+ *  IOW, a future version of the library may make the transformations flag
+ *  a bit more fine-grained, with separate bits for each of these three
+ *  functions.
+ *
+ *  More to the point, these functions make it obvious what libpng will be
+ *  doing, whereas "expand" can (and does) mean any number of things.
+ *
+ *  GRP 20060307: In libpng-1.2.9, png_set_gray_1_2_4_to_8() was modified
+ *  to expand only the sample depth but not to expand the tRNS to alpha
+ *  and its name was changed to png_set_expand_gray_1_2_4_to_8().
+ */
+
+/* Expand paletted images to RGB. */
+void PNGAPI
+png_set_palette_to_rgb(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_palette_to_rgb");
+
+   if (png_ptr == NULL)
+      return;
+
+   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+
+/* Expand grayscale images of less than 8-bit depth to 8 bits. */
+void PNGAPI
+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");
+
+   if (png_ptr == NULL)
+      return;
+
+   png_ptr->transformations |= PNG_EXPAND;
+   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+
+
+
+/* Expand tRNS chunks to alpha channels. */
+void PNGAPI
+png_set_tRNS_to_alpha(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_tRNS_to_alpha");
+
+   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+void PNGAPI
+png_set_gray_to_rgb(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_gray_to_rgb");
+
+   png_ptr->transformations |= PNG_GRAY_TO_RGB;
+   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+}
+#endif
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+/* Convert a RGB image to a grayscale of the same width.  This allows us,
+ * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
+ */
+
+void PNGAPI
+png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
+   double green)
+{
+   int red_fixed = (int)((float)red*100000.0 + 0.5);
+   int green_fixed = (int)((float)green*100000.0 + 0.5);
+   if (png_ptr == NULL)
+      return;
+   png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
+}
+#endif
+
+void PNGAPI
+png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
+   png_fixed_point red, png_fixed_point green)
+{
+   png_debug(1, "in png_set_rgb_to_gray");
+
+   if (png_ptr == NULL)
+      return;
+
+   switch(error_action)
+   {
+      case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
+              break;
+
+      case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
+              break;
+
+      case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
+   }
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+#ifdef PNG_READ_EXPAND_SUPPORTED
+      png_ptr->transformations |= PNG_EXPAND;
+#else
+   {
+      png_warning(png_ptr,
+        "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");
+      png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
+   }
+#endif
+   {
+      png_uint_16 red_int, green_int;
+      if (red < 0 || green < 0)
+      {
+         red_int   =  6968; /* .212671 * 32768 + .5 */
+         green_int = 23434; /* .715160 * 32768 + .5 */
+      }
+      else if (red + green < 100000L)
+      {
+         red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
+         green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
+      }
+      else
+      {
+         png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");
+         red_int   =  6968;
+         green_int = 23434;
+      }
+      png_ptr->rgb_to_gray_red_coeff   = red_int;
+      png_ptr->rgb_to_gray_green_coeff = green_int;
+      png_ptr->rgb_to_gray_blue_coeff  =
+         (png_uint_16)(32768 - red_int - green_int);
+   }
+}
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+void PNGAPI
+png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
+   read_user_transform_fn)
+{
+   png_debug(1, "in png_set_read_user_transform_fn");
+
+   if (png_ptr == NULL)
+      return;
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+   png_ptr->transformations |= PNG_USER_TRANSFORM;
+   png_ptr->read_user_transform_fn = read_user_transform_fn;
+#endif
+}
+#endif
+
+/* Initialize everything needed for the read.  This includes modifying
+ * the palette.
+ */
+void /* PRIVATE */
+png_init_read_transformations(png_structp png_ptr)
+{
+   png_debug(1, "in png_init_read_transformations");
+
+  {
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \
+ || defined(PNG_READ_GAMMA_SUPPORTED)
+   int color_type = png_ptr->color_type;
+#endif
+
+#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+   /* Detect gray background and attempt to enable optimization
+    * for gray --> RGB case
+    *
+    * 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
+    * background color might actually be gray yet not be flagged as such.
+    * This is not a problem for the current code, which uses
+    * PNG_BACKGROUND_IS_GRAY only to decide when to do the
+    * png_do_gray_to_rgb() transformation.
+    */
+   if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+       !(color_type & PNG_COLOR_MASK_COLOR))
+   {
+          png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
+   } else if ((png_ptr->transformations & PNG_BACKGROUND) &&
+              !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+              (png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+              png_ptr->background.red == png_ptr->background.green &&
+              png_ptr->background.red == png_ptr->background.blue)
+   {
+          png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
+          png_ptr->background.gray = png_ptr->background.red;
+   }
+#endif
+
+   if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+       (png_ptr->transformations & PNG_EXPAND))
+   {
+      if (!(color_type & PNG_COLOR_MASK_COLOR))  /* i.e., GRAY or GRAY_ALPHA */
+      {
+         /* Expand background and tRNS chunks */
+         switch (png_ptr->bit_depth)
+         {
+            case 1:
+               png_ptr->background.gray *= (png_uint_16)0xff;
+               png_ptr->background.red = png_ptr->background.green
+                 =  png_ptr->background.blue = png_ptr->background.gray;
+               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+               {
+                 png_ptr->trans_color.gray *= (png_uint_16)0xff;
+                 png_ptr->trans_color.red = png_ptr->trans_color.green
+                   = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
+               }
+               break;
+
+            case 2:
+               png_ptr->background.gray *= (png_uint_16)0x55;
+               png_ptr->background.red = png_ptr->background.green
+                 = png_ptr->background.blue = png_ptr->background.gray;
+               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+               {
+                 png_ptr->trans_color.gray *= (png_uint_16)0x55;
+                 png_ptr->trans_color.red = png_ptr->trans_color.green
+                   = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
+               }
+               break;
+
+            case 4:
+               png_ptr->background.gray *= (png_uint_16)0x11;
+               png_ptr->background.red = png_ptr->background.green
+                 = png_ptr->background.blue = png_ptr->background.gray;
+               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+               {
+                 png_ptr->trans_color.gray *= (png_uint_16)0x11;
+                 png_ptr->trans_color.red = png_ptr->trans_color.green
+                   = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
+               }
+               break;
+
+            case 8:
+
+            case 16:
+               png_ptr->background.red = png_ptr->background.green
+                 = png_ptr->background.blue = png_ptr->background.gray;
+               break;
+         }
+      }
+      else if (color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         png_ptr->background.red   =
+            png_ptr->palette[png_ptr->background.index].red;
+         png_ptr->background.green =
+            png_ptr->palette[png_ptr->background.index].green;
+         png_ptr->background.blue  =
+            png_ptr->palette[png_ptr->background.index].blue;
+
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+        if (png_ptr->transformations & PNG_INVERT_ALPHA)
+        {
+#ifdef PNG_READ_EXPAND_SUPPORTED
+           if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+#endif
+           {
+           /* Invert the alpha channel (in tRNS) unless the pixels are
+            * going to be expanded, in which case leave it for later
+            */
+              int i, istop;
+              istop=(int)png_ptr->num_trans;
+              for (i=0; i<istop; i++)
+                 png_ptr->trans_alpha[i] = (png_byte)(255 - png_ptr->trans_alpha[i]);
+           }
+        }
+#endif
+
+      }
+   }
+#endif
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
+   png_ptr->background_1 = png_ptr->background;
+#endif
+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+
+   if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)
+       && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)
+         < PNG_GAMMA_THRESHOLD))
+   {
+    int i, k;
+    k=0;
+    for (i=0; i<png_ptr->num_trans; i++)
+    {
+      if (png_ptr->trans_alpha[i] != 0 && png_ptr->trans_alpha[i] != 0xff)
+        k=1; /* Partial transparency is present */
+    }
+    if (k == 0)
+      png_ptr->transformations &= ~PNG_GAMMA;
+   }
+
+   if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&
+        png_ptr->gamma != 0.0)
+   {
+      png_build_gamma_table(png_ptr, png_ptr->bit_depth);
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+      if (png_ptr->transformations & PNG_BACKGROUND)
+      {
+         if (color_type == PNG_COLOR_TYPE_PALETTE)
+         {
+           /* Could skip if no transparency */
+            png_color back, back_1;
+            png_colorp palette = png_ptr->palette;
+            int num_palette = png_ptr->num_palette;
+            int i;
+            if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
+            {
+               back.red = png_ptr->gamma_table[png_ptr->background.red];
+               back.green = png_ptr->gamma_table[png_ptr->background.green];
+               back.blue = png_ptr->gamma_table[png_ptr->background.blue];
+
+               back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
+               back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
+               back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
+            }
+            else
+            {
+               double g, gs;
+
+               switch (png_ptr->background_gamma_type)
+               {
+                  case PNG_BACKGROUND_GAMMA_SCREEN:
+                     g = (png_ptr->screen_gamma);
+                     gs = 1.0;
+                     break;
+
+                  case PNG_BACKGROUND_GAMMA_FILE:
+                     g = 1.0 / (png_ptr->gamma);
+                     gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+                     break;
+
+                  case PNG_BACKGROUND_GAMMA_UNIQUE:
+                     g = 1.0 / (png_ptr->background_gamma);
+                     gs = 1.0 / (png_ptr->background_gamma *
+                                 png_ptr->screen_gamma);
+                     break;
+                  default:
+                     g = 1.0;    /* back_1 */
+                     gs = 1.0;   /* back */
+               }
+
+               if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)
+               {
+                  back.red   = (png_byte)png_ptr->background.red;
+                  back.green = (png_byte)png_ptr->background.green;
+                  back.blue  = (png_byte)png_ptr->background.blue;
+               }
+               else
+               {
+                  back.red = (png_byte)(pow(
+                     (double)png_ptr->background.red/255.0, gs) * 255.0 + .5);
+                  back.green = (png_byte)(pow(
+                     (double)png_ptr->background.green/255.0, gs) * 255.0 + .5);
+                  back.blue = (png_byte)(pow(
+                     (double)png_ptr->background.blue/255.0, gs) * 255.0 + .5);
+               }
+
+               back_1.red = (png_byte)(pow(
+                  (double)png_ptr->background.red/255.0, g) * 255.0 + .5);
+               back_1.green = (png_byte)(pow(
+                  (double)png_ptr->background.green/255.0, g) * 255.0 + .5);
+               back_1.blue = (png_byte)(pow(
+                  (double)png_ptr->background.blue/255.0, g) * 255.0 + .5);
+            }
+            for (i = 0; i < num_palette; i++)
+            {
+               if (i < (int)png_ptr->num_trans && png_ptr->trans_alpha[i] != 0xff)
+               {
+                  if (png_ptr->trans_alpha[i] == 0)
+                  {
+                     palette[i] = back;
+                  }
+                  else /* if (png_ptr->trans_alpha[i] != 0xff) */
+                  {
+                     png_byte v, w;
+
+                     v = png_ptr->gamma_to_1[palette[i].red];
+                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);
+                     palette[i].red = png_ptr->gamma_from_1[w];
+
+                     v = png_ptr->gamma_to_1[palette[i].green];
+                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);
+                     palette[i].green = png_ptr->gamma_from_1[w];
+
+                     v = png_ptr->gamma_to_1[palette[i].blue];
+                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);
+                     palette[i].blue = png_ptr->gamma_from_1[w];
+                  }
+               }
+               else
+               {
+                  palette[i].red = png_ptr->gamma_table[palette[i].red];
+                  palette[i].green = png_ptr->gamma_table[palette[i].green];
+                  palette[i].blue = png_ptr->gamma_table[palette[i].blue];
+               }
+            }
+            /* Prevent the transformations being done again, and make sure
+             * that the now spurious alpha channel is stripped - the code
+             * has just reduced background composition and gamma correction
+             * to a simple alpha channel strip.
+             */
+            png_ptr->transformations &= ~PNG_BACKGROUND;
+            png_ptr->transformations &= ~PNG_GAMMA;
+            png_ptr->transformations |= PNG_STRIP_ALPHA;
+         }
+         /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
+         else
+         /* color_type != PNG_COLOR_TYPE_PALETTE */
+         {
+            double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);
+            double g = 1.0;
+            double gs = 1.0;
+
+            switch (png_ptr->background_gamma_type)
+            {
+               case PNG_BACKGROUND_GAMMA_SCREEN:
+                  g = (png_ptr->screen_gamma);
+                  gs = 1.0;
+                  break;
+
+               case PNG_BACKGROUND_GAMMA_FILE:
+                  g = 1.0 / (png_ptr->gamma);
+                  gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+                  break;
+
+               case PNG_BACKGROUND_GAMMA_UNIQUE:
+                  g = 1.0 / (png_ptr->background_gamma);
+                  gs = 1.0 / (png_ptr->background_gamma *
+                     png_ptr->screen_gamma);
+                  break;
+            }
+
+            png_ptr->background_1.gray = (png_uint_16)(pow(
+               (double)png_ptr->background.gray / m, g) * m + .5);
+            png_ptr->background.gray = (png_uint_16)(pow(
+               (double)png_ptr->background.gray / m, gs) * m + .5);
+
+            if ((png_ptr->background.red != png_ptr->background.green) ||
+                (png_ptr->background.red != png_ptr->background.blue) ||
+                (png_ptr->background.red != png_ptr->background.gray))
+            {
+               /* RGB or RGBA with color background */
+               png_ptr->background_1.red = (png_uint_16)(pow(
+                  (double)png_ptr->background.red / m, g) * m + .5);
+               png_ptr->background_1.green = (png_uint_16)(pow(
+                  (double)png_ptr->background.green / m, g) * m + .5);
+               png_ptr->background_1.blue = (png_uint_16)(pow(
+                  (double)png_ptr->background.blue / m, g) * m + .5);
+               png_ptr->background.red = (png_uint_16)(pow(
+                  (double)png_ptr->background.red / m, gs) * m + .5);
+               png_ptr->background.green = (png_uint_16)(pow(
+                  (double)png_ptr->background.green / m, gs) * m + .5);
+               png_ptr->background.blue = (png_uint_16)(pow(
+                  (double)png_ptr->background.blue / m, gs) * m + .5);
+            }
+            else
+            {
+               /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
+               png_ptr->background_1.red = png_ptr->background_1.green
+                 = png_ptr->background_1.blue = png_ptr->background_1.gray;
+               png_ptr->background.red = png_ptr->background.green
+                 = png_ptr->background.blue = png_ptr->background.gray;
+            }
+         }
+      }
+      else
+      /* Transformation does not include PNG_BACKGROUND */
+#endif /* PNG_READ_BACKGROUND_SUPPORTED */
+      if (color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         png_colorp palette = png_ptr->palette;
+         int num_palette = png_ptr->num_palette;
+         int i;
+
+         for (i = 0; i < num_palette; i++)
+         {
+            palette[i].red = png_ptr->gamma_table[palette[i].red];
+            palette[i].green = png_ptr->gamma_table[palette[i].green];
+            palette[i].blue = png_ptr->gamma_table[palette[i].blue];
+         }
+
+         /* Done the gamma correction. */
+         png_ptr->transformations &= ~PNG_GAMMA;
+      }
+   }
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+   else
+#endif
+#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+   /* No GAMMA transformation */
+   if ((png_ptr->transformations & PNG_BACKGROUND) &&
+       (color_type == PNG_COLOR_TYPE_PALETTE))
+   {
+      int i;
+      int istop = (int)png_ptr->num_trans;
+      png_color back;
+      png_colorp palette = png_ptr->palette;
+
+      back.red   = (png_byte)png_ptr->background.red;
+      back.green = (png_byte)png_ptr->background.green;
+      back.blue  = (png_byte)png_ptr->background.blue;
+
+      for (i = 0; i < istop; i++)
+      {
+         if (png_ptr->trans_alpha[i] == 0)
+         {
+            palette[i] = back;
+         }
+         else if (png_ptr->trans_alpha[i] != 0xff)
+         {
+            /* The png_composite() macro is defined in png.h */
+            png_composite(palette[i].red, palette[i].red,
+               png_ptr->trans_alpha[i], back.red);
+            png_composite(palette[i].green, palette[i].green,
+               png_ptr->trans_alpha[i], back.green);
+            png_composite(palette[i].blue, palette[i].blue,
+               png_ptr->trans_alpha[i], back.blue);
+         }
+      }
+
+      /* Handled alpha, still need to strip the channel. */
+      png_ptr->transformations &= ~PNG_BACKGROUND;
+      png_ptr->transformations |= PNG_STRIP_ALPHA;
+   }
+#endif /* PNG_READ_BACKGROUND_SUPPORTED */
+
+#ifdef PNG_READ_SHIFT_SUPPORTED
+   if ((png_ptr->transformations & PNG_SHIFT) &&
+      (color_type == PNG_COLOR_TYPE_PALETTE))
+   {
+      png_uint_16 i;
+      png_uint_16 istop = png_ptr->num_palette;
+      int sr = 8 - png_ptr->sig_bit.red;
+      int sg = 8 - png_ptr->sig_bit.green;
+      int sb = 8 - png_ptr->sig_bit.blue;
+
+      if (sr < 0 || sr > 8)
+         sr = 0;
+      if (sg < 0 || sg > 8)
+         sg = 0;
+      if (sb < 0 || sb > 8)
+         sb = 0;
+      for (i = 0; i < istop; i++)
+      {
+         png_ptr->palette[i].red >>= sr;
+         png_ptr->palette[i].green >>= sg;
+         png_ptr->palette[i].blue >>= sb;
+      }
+   }
+#endif  /* PNG_READ_SHIFT_SUPPORTED */
+ }
+#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \
+ && !defined(PNG_READ_BACKGROUND_SUPPORTED)
+   if (png_ptr)
+      return;
+#endif
+}
+
+/* Modify the info structure to reflect the transformations.  The
+ * info should be updated so a PNG file could be written with it,
+ * assuming the transformations result in valid PNG data.
+ */
+void /* PRIVATE */
+png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_read_transform_info");
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+   if (png_ptr->transformations & PNG_EXPAND)
+   {
+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         if (png_ptr->num_trans &&
+              (png_ptr->transformations & PNG_EXPAND_tRNS))
+            info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+         else
+            info_ptr->color_type = PNG_COLOR_TYPE_RGB;
+         info_ptr->bit_depth = 8;
+         info_ptr->num_trans = 0;
+      }
+      else
+      {
+         if (png_ptr->num_trans)
+         {
+            if (png_ptr->transformations & PNG_EXPAND_tRNS)
+              info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
+         }
+         if (info_ptr->bit_depth < 8)
+            info_ptr->bit_depth = 8;
+         info_ptr->num_trans = 0;
+      }
+   }
+#endif
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+   if (png_ptr->transformations & PNG_BACKGROUND)
+   {
+      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
+      info_ptr->num_trans = 0;
+      info_ptr->background = png_ptr->background;
+   }
+#endif
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   if (png_ptr->transformations & PNG_GAMMA)
+   {
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+      info_ptr->gamma = png_ptr->gamma;
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+      info_ptr->int_gamma = png_ptr->int_gamma;
+#endif
+   }
+#endif
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+   if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
+      info_ptr->bit_depth = 8;
+#endif
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+   if (png_ptr->transformations & PNG_GRAY_TO_RGB)
+      info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
+#endif
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+   if (png_ptr->transformations & PNG_RGB_TO_GRAY)
+      info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
+#endif
+
+#ifdef PNG_READ_DITHER_SUPPORTED
+   if (png_ptr->transformations & PNG_DITHER)
+   {
+      if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
+          (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
+          png_ptr->palette_lookup && info_ptr->bit_depth == 8)
+      {
+         info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
+      }
+   }
+#endif
+
+#ifdef PNG_READ_PACK_SUPPORTED
+   if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
+      info_ptr->bit_depth = 8;
+#endif
+
+   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      info_ptr->channels = 1;
+   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
+      info_ptr->channels = 3;
+   else
+      info_ptr->channels = 1;
+
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
+      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
+#endif
+
+   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
+      info_ptr->channels++;
+
+#ifdef PNG_READ_FILLER_SUPPORTED
+   /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */
+   if ((png_ptr->transformations & PNG_FILLER) &&
+       ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
+       (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
+   {
+      info_ptr->channels++;
+      /* If adding a true alpha channel not just filler */
+      if (png_ptr->transformations & PNG_ADD_ALPHA)
+        info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
+   }
+#endif
+
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
+defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+     {
+       if (info_ptr->bit_depth < png_ptr->user_transform_depth)
+         info_ptr->bit_depth = png_ptr->user_transform_depth;
+       if (info_ptr->channels < png_ptr->user_transform_channels)
+         info_ptr->channels = png_ptr->user_transform_channels;
+     }
+#endif
+
+   info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
+      info_ptr->bit_depth);
+
+   info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
+
+#ifndef PNG_READ_EXPAND_SUPPORTED
+   if (png_ptr)
+      return;
+#endif
+}
+
+/* Transform the row.  The order of transformations is significant,
+ * and is very touchy.  If you add a transformation, take care to
+ * decide how it fits in with the other transformations here.
+ */
+void /* PRIVATE */
+png_do_read_transformations(png_structp png_ptr)
+{
+   png_debug(1, "in png_do_read_transformations");
+
+   if (png_ptr->row_buf == NULL)
+   {
+#ifdef PNG_STDIO_SUPPORTED
+      char msg[50];
+
+      png_snprintf2(msg, 50,
+         "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,
+         png_ptr->pass);
+      png_error(png_ptr, msg);
+#else
+      png_error(png_ptr, "NULL row buffer");
+#endif
+   }
+#ifdef PNG_WARN_UNINITIALIZED_ROW
+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+      /* Application has failed to call either png_read_start_image()
+       * or png_read_update_info() after setting transforms that expand
+       * pixels.  This check added to libpng-1.2.19
+       */
+#if (PNG_WARN_UNINITIALIZED_ROW==1)
+      png_error(png_ptr, "Uninitialized row");
+#else
+      png_warning(png_ptr, "Uninitialized row");
+#endif
+#endif
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+   if (png_ptr->transformations & PNG_EXPAND)
+   {
+      if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
+            png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
+      }
+      else
+      {
+         if (png_ptr->num_trans &&
+             (png_ptr->transformations & PNG_EXPAND_tRNS))
+            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
+               &(png_ptr->trans_color));
+         else
+            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
+               NULL);
+      }
+   }
+#endif
+
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
+      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));
+#endif
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+   if (png_ptr->transformations & PNG_RGB_TO_GRAY)
+   {
+      int rgb_error =
+         png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);
+      if (rgb_error)
+      {
+         png_ptr->rgb_to_gray_status=1;
+         if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
+             PNG_RGB_TO_GRAY_WARN)
+            png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
+         if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
+             PNG_RGB_TO_GRAY_ERR)
+            png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
+      }
+   }
+#endif
+
+/* From Andreas Dilger e-mail to png-implement, 26 March 1998:
+ *
+ *   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
+ *   pixel is transparent.  You would also need to make sure that the
+ *   transparency information is upgraded to RGB.
+ *
+ *   To summarize, the current flow is:
+ *   - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
+ *                                   with background "in place" if transparent,
+ *                                   convert to RGB if necessary
+ *   - Gray + alpha -> composite with gray background and remove alpha bytes,
+ *                                   convert to RGB if necessary
+ *
+ *   To support RGB backgrounds for gray images we need:
+ *   - Gray + simple transparency -> convert to RGB + simple transparency,
+ *                                   compare 3 or 6 bytes and composite with
+ *                                   background "in place" if transparent
+ *                                   (3x compare/pixel compared to doing
+ *                                   composite with gray bkgrnd)
+ *   - Gray + alpha -> convert to RGB + alpha, composite with background and
+ *                                   remove alpha bytes (3x float
+ *                                   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
+ *  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.
+ */
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+   /* If gray -> RGB, do so now only if background is non-gray; else do later
+    * for performance reasons
+    */
+   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+       !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
+      png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+   if ((png_ptr->transformations & PNG_BACKGROUND) &&
+      ((png_ptr->num_trans != 0 ) ||
+      (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
+      png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         &(png_ptr->trans_color), &(png_ptr->background)
+#ifdef PNG_READ_GAMMA_SUPPORTED
+         , &(png_ptr->background_1),
+         png_ptr->gamma_table, png_ptr->gamma_from_1,
+         png_ptr->gamma_to_1, png_ptr->gamma_16_table,
+         png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
+         png_ptr->gamma_shift
+#endif
+);
+#endif
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   if ((png_ptr->transformations & PNG_GAMMA) &&
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+       !((png_ptr->transformations & PNG_BACKGROUND) &&
+       ((png_ptr->num_trans != 0) ||
+       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
+#endif
+       (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
+      png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
+          png_ptr->gamma_table, png_ptr->gamma_16_table,
+          png_ptr->gamma_shift);
+#endif
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+   if (png_ptr->transformations & PNG_16_TO_8)
+      png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_DITHER_SUPPORTED
+   if (png_ptr->transformations & PNG_DITHER)
+   {
+      png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
+         png_ptr->palette_lookup, png_ptr->dither_index);
+      if (png_ptr->row_info.rowbytes == (png_uint_32)0)
+         png_error(png_ptr, "png_do_dither returned rowbytes=0");
+   }
+#endif
+
+#ifdef PNG_READ_INVERT_SUPPORTED
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_SHIFT_SUPPORTED
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         &(png_ptr->shift));
+#endif
+
+#ifdef PNG_READ_PACK_SUPPORTED
+   if (png_ptr->transformations & PNG_PACK)
+      png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_BGR_SUPPORTED
+   if (png_ptr->transformations & PNG_BGR)
+      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+   /* If gray -> RGB, do so now only if we did not do so above */
+   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+       (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
+      png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_FILLER_SUPPORTED
+   if (png_ptr->transformations & PNG_FILLER)
+      png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         (png_uint_32)png_ptr->filler, png_ptr->flags);
+#endif
+
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+   if (png_ptr->transformations & PNG_INVERT_ALPHA)
+      png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+   if (png_ptr->transformations & PNG_SWAP_ALPHA)
+      png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_SWAP_SUPPORTED
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+    {
+      if (png_ptr->read_user_transform_fn != NULL)
+         (*(png_ptr->read_user_transform_fn)) /* User read transform function */
+            (png_ptr,                    /* png_ptr */
+               &(png_ptr->row_info),     /* row_info: */
+               /*  png_uint_32 width;       width of row */
+               /*  png_uint_32 rowbytes;    number of bytes in row */
+               /*  png_byte color_type;     color type of pixels */
+               /*  png_byte bit_depth;      bit depth of samples */
+               /*  png_byte channels;       number of channels (1-4) */
+               /*  png_byte pixel_depth;    bits per pixel (depth*channels) */
+               png_ptr->row_buf + 1);    /* start of pixel data for row */
+#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+      if (png_ptr->user_transform_depth)
+         png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
+      if (png_ptr->user_transform_channels)
+         png_ptr->row_info.channels = png_ptr->user_transform_channels;
+#endif
+      png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
+         png_ptr->row_info.channels);
+      png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+         png_ptr->row_info.width);
+   }
+#endif
+
+}
+
+#ifdef PNG_READ_PACK_SUPPORTED
+/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
+ * without changing the actual values.  Thus, if you had a row with
+ * a bit depth of 1, you would end up with bytes that only contained
+ * the numbers 0 or 1.  If you would rather they contain 0 and 255, use
+ * png_do_shift() after this.
+ */
+void /* PRIVATE */
+png_do_unpack(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_unpack");
+
+   if (row_info->bit_depth < 8)
+   {
+      png_uint_32 i;
+      png_uint_32 row_width=row_info->width;
+
+      switch (row_info->bit_depth)
+      {
+         case 1:
+         {
+            png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
+            png_bytep dp = row + (png_size_t)row_width - 1;
+            png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);
+            for (i = 0; i < row_width; i++)
+            {
+               *dp = (png_byte)((*sp >> shift) & 0x01);
+               if (shift == 7)
+               {
+                  shift = 0;
+                  sp--;
+               }
+               else
+                  shift++;
+
+               dp--;
+            }
+            break;
+         }
+
+         case 2:
+         {
+
+            png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
+            png_bytep dp = row + (png_size_t)row_width - 1;
+            png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+            for (i = 0; i < row_width; i++)
+            {
+               *dp = (png_byte)((*sp >> shift) & 0x03);
+               if (shift == 6)
+               {
+                  shift = 0;
+                  sp--;
+               }
+               else
+                  shift += 2;
+
+               dp--;
+            }
+            break;
+         }
+
+         case 4:
+         {
+            png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
+            png_bytep dp = row + (png_size_t)row_width - 1;
+            png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
+            for (i = 0; i < row_width; i++)
+            {
+               *dp = (png_byte)((*sp >> shift) & 0x0f);
+               if (shift == 4)
+               {
+                  shift = 0;
+                  sp--;
+               }
+               else
+                  shift = 4;
+
+               dp--;
+            }
+            break;
+         }
+      }
+      row_info->bit_depth = 8;
+      row_info->pixel_depth = (png_byte)(8 * row_info->channels);
+      row_info->rowbytes = row_width * row_info->channels;
+   }
+}
+#endif
+
+#ifdef PNG_READ_SHIFT_SUPPORTED
+/* Reverse the effects of png_do_shift.  This routine merely shifts the
+ * pixels back to their significant bits values.  Thus, if you have
+ * a row of bit depth 8, but only 5 are significant, this will shift
+ * the values back to 0 through 31.
+ */
+void /* PRIVATE */
+png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
+{
+   png_debug(1, "in png_do_unshift");
+
+   if (
+       row_info->color_type != PNG_COLOR_TYPE_PALETTE)
+   {
+      int shift[4];
+      int channels = 0;
+      int c;
+      png_uint_16 value = 0;
+      png_uint_32 row_width = row_info->width;
+
+      if (row_info->color_type & PNG_COLOR_MASK_COLOR)
+      {
+         shift[channels++] = row_info->bit_depth - sig_bits->red;
+         shift[channels++] = row_info->bit_depth - sig_bits->green;
+         shift[channels++] = row_info->bit_depth - sig_bits->blue;
+      }
+      else
+      {
+         shift[channels++] = row_info->bit_depth - sig_bits->gray;
+      }
+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
+      {
+         shift[channels++] = row_info->bit_depth - sig_bits->alpha;
+      }
+
+      for (c = 0; c < channels; c++)
+      {
+         if (shift[c] <= 0)
+            shift[c] = 0;
+         else
+            value = 1;
+      }
+
+      if (!value)
+         return;
+
+      switch (row_info->bit_depth)
+      {
+         case 2:
+         {
+            png_bytep bp;
+            png_uint_32 i;
+            png_uint_32 istop = row_info->rowbytes;
+
+            for (bp = row, i = 0; i < istop; i++)
+            {
+               *bp >>= 1;
+               *bp++ &= 0x55;
+            }
+            break;
+         }
+
+         case 4:
+         {
+            png_bytep bp = row;
+            png_uint_32 i;
+            png_uint_32 istop = row_info->rowbytes;
+            png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |
+               (png_byte)((int)0xf >> shift[0]));
+
+            for (i = 0; i < istop; i++)
+            {
+               *bp >>= shift[0];
+               *bp++ &= mask;
+            }
+            break;
+         }
+
+         case 8:
+         {
+            png_bytep bp = row;
+            png_uint_32 i;
+            png_uint_32 istop = row_width * channels;
+
+            for (i = 0; i < istop; i++)
+            {
+               *bp++ >>= shift[i%channels];
+            }
+            break;
+         }
+
+         case 16:
+         {
+            png_bytep bp = row;
+            png_uint_32 i;
+            png_uint_32 istop = channels * row_width;
+
+            for (i = 0; i < istop; i++)
+            {
+               value = (png_uint_16)((*bp << 8) + *(bp + 1));
+               value >>= shift[i%channels];
+               *bp++ = (png_byte)(value >> 8);
+               *bp++ = (png_byte)(value & 0xff);
+            }
+            break;
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+/* Chop rows of bit depth 16 down to 8 */
+void /* PRIVATE */
+png_do_chop(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_chop");
+
+   if (row_info->bit_depth == 16)
+   {
+      png_bytep sp = row;
+      png_bytep dp = row;
+      png_uint_32 i;
+      png_uint_32 istop = row_info->width * row_info->channels;
+
+      for (i = 0; i<istop; i++, sp += 2, dp++)
+      {
+#ifdef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+      /* This does a more accurate scaling of the 16-bit color
+       * value, rather than a simple low-byte truncation.
+       *
+       * What the ideal calculation should be:
+       *   *dp = (((((png_uint_32)(*sp) << 8) |
+       *          (png_uint_32)(*(sp + 1))) * 255 + 127)
+       *          / (png_uint_32)65535L;
+       *
+       * GRR: no, I think this is what it really should be:
+       *   *dp = (((((png_uint_32)(*sp) << 8) |
+       *           (png_uint_32)(*(sp + 1))) + 128L)
+       *           / (png_uint_32)257L;
+       *
+       * GRR: here's the exact calculation with shifts:
+       *   temp = (((png_uint_32)(*sp) << 8) |
+       *           (png_uint_32)(*(sp + 1))) + 128L;
+       *   *dp = (temp - (temp >> 8)) >> 8;
+       *
+       * Approximate calculation with shift/add instead of multiply/divide:
+       *   *dp = ((((png_uint_32)(*sp) << 8) |
+       *          (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;
+       *
+       * What we actually do to avoid extra shifting and conversion:
+       */
+
+         *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);
+#else
+       /* Simply discard the low order byte */
+         *dp = *sp;
+#endif
+      }
+      row_info->bit_depth = 8;
+      row_info->pixel_depth = (png_byte)(8 * row_info->channels);
+      row_info->rowbytes = row_info->width * row_info->channels;
+   }
+}
+#endif
+
+#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+void /* PRIVATE */
+png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_read_swap_alpha");
+
+   {
+      png_uint_32 row_width = row_info->width;
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         /* This converts from RGBA to ARGB */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_byte save;
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               save = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = save;
+            }
+         }
+         /* This converts from RRGGBBAA to AARRGGBB */
+         else
+         {
+            png_bytep sp = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_byte save[2];
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               save[0] = *(--sp);
+               save[1] = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = save[0];
+               *(--dp) = save[1];
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         /* This converts from GA to AG */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_byte save;
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               save = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = save;
+            }
+         }
+         /* This converts from GGAA to AAGG */
+         else
+         {
+            png_bytep sp = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_byte save[2];
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               save[0] = *(--sp);
+               save[1] = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = save[0];
+               *(--dp) = save[1];
+            }
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+void /* PRIVATE */
+png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_read_invert_alpha");
+
+   {
+      png_uint_32 row_width = row_info->width;
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         /* This inverts the alpha channel in RGBA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = (png_byte)(255 - *(--sp));
+
+/*             This does nothing:
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               We can replace it with:
+*/
+               sp-=3;
+               dp=sp;
+            }
+         }
+         /* This inverts the alpha channel in RRGGBBAA */
+         else
+         {
+            png_bytep sp = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = (png_byte)(255 - *(--sp));
+               *(--dp) = (png_byte)(255 - *(--sp));
+
+/*             This does nothing:
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               We can replace it with:
+*/
+               sp-=6;
+               dp=sp;
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         /* This inverts the alpha channel in GA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = (png_byte)(255 - *(--sp));
+               *(--dp) = *(--sp);
+            }
+         }
+         /* This inverts the alpha channel in GGAA */
+         else
+         {
+            png_bytep sp  = row + row_info->rowbytes;
+            png_bytep dp = sp;
+            png_uint_32 i;
+
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = (png_byte)(255 - *(--sp));
+               *(--dp) = (png_byte)(255 - *(--sp));
+/*
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+*/
+               sp-=2;
+               dp=sp;
+            }
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_READ_FILLER_SUPPORTED
+/* Add filler channel if we have RGB color */
+void /* PRIVATE */
+png_do_read_filler(png_row_infop row_info, png_bytep row,
+   png_uint_32 filler, png_uint_32 flags)
+{
+   png_uint_32 i;
+   png_uint_32 row_width = row_info->width;
+
+   png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
+   png_byte lo_filler = (png_byte)(filler & 0xff);
+
+   png_debug(1, "in png_do_read_filler");
+
+   if (
+       row_info->color_type == PNG_COLOR_TYPE_GRAY)
+   {
+      if (row_info->bit_depth == 8)
+      {
+         /* This changes the data from G to GX */
+         if (flags & PNG_FLAG_FILLER_AFTER)
+         {
+            png_bytep sp = row + (png_size_t)row_width;
+            png_bytep dp =  sp + (png_size_t)row_width;
+            for (i = 1; i < row_width; i++)
+            {
+               *(--dp) = lo_filler;
+               *(--dp) = *(--sp);
+            }
+            *(--dp) = lo_filler;
+            row_info->channels = 2;
+            row_info->pixel_depth = 16;
+            row_info->rowbytes = row_width * 2;
+         }
+      /* This changes the data from G to XG */
+         else
+         {
+            png_bytep sp = row + (png_size_t)row_width;
+            png_bytep dp = sp  + (png_size_t)row_width;
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = *(--sp);
+               *(--dp) = lo_filler;
+            }
+            row_info->channels = 2;
+            row_info->pixel_depth = 16;
+            row_info->rowbytes = row_width * 2;
+         }
+      }
+      else if (row_info->bit_depth == 16)
+      {
+         /* This changes the data from GG to GGXX */
+         if (flags & PNG_FLAG_FILLER_AFTER)
+         {
+            png_bytep sp = row + (png_size_t)row_width * 2;
+            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            for (i = 1; i < row_width; i++)
+            {
+               *(--dp) = hi_filler;
+               *(--dp) = lo_filler;
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+            }
+            *(--dp) = hi_filler;
+            *(--dp) = lo_filler;
+            row_info->channels = 2;
+            row_info->pixel_depth = 32;
+            row_info->rowbytes = row_width * 4;
+         }
+         /* This changes the data from GG to XXGG */
+         else
+         {
+            png_bytep sp = row + (png_size_t)row_width * 2;
+            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = hi_filler;
+               *(--dp) = lo_filler;
+            }
+            row_info->channels = 2;
+            row_info->pixel_depth = 32;
+            row_info->rowbytes = row_width * 4;
+         }
+      }
+   } /* COLOR_TYPE == GRAY */
+   else if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+   {
+      if (row_info->bit_depth == 8)
+      {
+         /* This changes the data from RGB to RGBX */
+         if (flags & PNG_FLAG_FILLER_AFTER)
+         {
+            png_bytep sp = row + (png_size_t)row_width * 3;
+            png_bytep dp = sp  + (png_size_t)row_width;
+            for (i = 1; i < row_width; i++)
+            {
+               *(--dp) = lo_filler;
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+            }
+            *(--dp) = lo_filler;
+            row_info->channels = 4;
+            row_info->pixel_depth = 32;
+            row_info->rowbytes = row_width * 4;
+         }
+      /* This changes the data from RGB to XRGB */
+         else
+         {
+            png_bytep sp = row + (png_size_t)row_width * 3;
+            png_bytep dp = sp + (png_size_t)row_width;
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = lo_filler;
+            }
+            row_info->channels = 4;
+            row_info->pixel_depth = 32;
+            row_info->rowbytes = row_width * 4;
+         }
+      }
+      else if (row_info->bit_depth == 16)
+      {
+         /* This changes the data from RRGGBB to RRGGBBXX */
+         if (flags & PNG_FLAG_FILLER_AFTER)
+         {
+            png_bytep sp = row + (png_size_t)row_width * 6;
+            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            for (i = 1; i < row_width; i++)
+            {
+               *(--dp) = hi_filler;
+               *(--dp) = lo_filler;
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+            }
+            *(--dp) = hi_filler;
+            *(--dp) = lo_filler;
+            row_info->channels = 4;
+            row_info->pixel_depth = 64;
+            row_info->rowbytes = row_width * 8;
+         }
+         /* This changes the data from RRGGBB to XXRRGGBB */
+         else
+         {
+            png_bytep sp = row + (png_size_t)row_width * 6;
+            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            for (i = 0; i < row_width; i++)
+            {
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = *(--sp);
+               *(--dp) = hi_filler;
+               *(--dp) = lo_filler;
+            }
+            row_info->channels = 4;
+            row_info->pixel_depth = 64;
+            row_info->rowbytes = row_width * 8;
+         }
+      }
+   } /* COLOR_TYPE == RGB */
+}
+#endif
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+/* Expand grayscale files to RGB, with or without alpha */
+void /* PRIVATE */
+png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
+{
+   png_uint_32 i;
+   png_uint_32 row_width = row_info->width;
+
+   png_debug(1, "in png_do_gray_to_rgb");
+
+   if (row_info->bit_depth >= 8 &&
+      !(row_info->color_type & PNG_COLOR_MASK_COLOR))
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+      {
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp = row + (png_size_t)row_width - 1;
+            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            for (i = 0; i < row_width; i++)
+            {
+               *(dp--) = *sp;
+               *(dp--) = *sp;
+               *(dp--) = *(sp--);
+            }
+         }
+         else
+         {
+            png_bytep sp = row + (png_size_t)row_width * 2 - 1;
+            png_bytep dp = sp  + (png_size_t)row_width * 4;
+            for (i = 0; i < row_width; i++)
+            {
+               *(dp--) = *sp;
+               *(dp--) = *(sp - 1);
+               *(dp--) = *sp;
+               *(dp--) = *(sp - 1);
+               *(dp--) = *(sp--);
+               *(dp--) = *(sp--);
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp = row + (png_size_t)row_width * 2 - 1;
+            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            for (i = 0; i < row_width; i++)
+            {
+               *(dp--) = *(sp--);
+               *(dp--) = *sp;
+               *(dp--) = *sp;
+               *(dp--) = *(sp--);
+            }
+         }
+         else
+         {
+            png_bytep sp = row + (png_size_t)row_width * 4 - 1;
+            png_bytep dp = sp  + (png_size_t)row_width * 4;
+            for (i = 0; i < row_width; i++)
+            {
+               *(dp--) = *(sp--);
+               *(dp--) = *(sp--);
+               *(dp--) = *sp;
+               *(dp--) = *(sp - 1);
+               *(dp--) = *sp;
+               *(dp--) = *(sp - 1);
+               *(dp--) = *(sp--);
+               *(dp--) = *(sp--);
+            }
+         }
+      }
+      row_info->channels += (png_byte)2;
+      row_info->color_type |= PNG_COLOR_MASK_COLOR;
+      row_info->pixel_depth = (png_byte)(row_info->channels *
+         row_info->bit_depth);
+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+   }
+}
+#endif
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+/* Reduce RGB files to grayscale, with or without alpha
+ * using the equation given in Poynton's ColorFAQ at
+ * <http://www.inforamp.net/~poynton/>  (THIS LINK IS DEAD June 2008)
+ * New link:
+ * <http://www.poynton.com/notes/colour_and_gamma/>
+ * Charles Poynton poynton at poynton.com
+ *
+ *     Y = 0.212671 * R + 0.715160 * G + 0.072169 * B
+ *
+ *  We approximate this with
+ *
+ *     Y = 0.21268 * R    + 0.7151 * G    + 0.07217 * B
+ *
+ *  which can be expressed with integers as
+ *
+ *     Y = (6969 * R + 23434 * G + 2365 * B)/32768
+ *
+ *  The calculation is to be done in a linear colorspace.
+ *
+ *  Other integer coefficents can be used via png_set_rgb_to_gray().
+ */
+int /* PRIVATE */
+png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
+
+{
+   png_uint_32 i;
+
+   png_uint_32 row_width = row_info->width;
+   int rgb_error = 0;
+
+   png_debug(1, "in png_do_rgb_to_gray");
+
+   if (
+      (row_info->color_type & PNG_COLOR_MASK_COLOR))
+   {
+      png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
+      png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
+      png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
+
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+      {
+         if (row_info->bit_depth == 8)
+         {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+
+               for (i = 0; i < row_width; i++)
+               {
+                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];
+                  png_byte green = png_ptr->gamma_to_1[*(sp++)];
+                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];
+                  if (red != green || red != blue)
+                  {
+                     rgb_error |= 1;
+                     *(dp++) = png_ptr->gamma_from_1[
+                       (rc*red + gc*green + bc*blue)>>15];
+                  }
+                  else
+                     *(dp++) = *(sp - 1);
+               }
+            }
+            else
+#endif
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_byte red   = *(sp++);
+                  png_byte green = *(sp++);
+                  png_byte blue  = *(sp++);
+                  if (red != green || red != blue)
+                  {
+                     rgb_error |= 1;
+                     *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
+                  }
+                  else
+                     *(dp++) = *(sp - 1);
+               }
+            }
+         }
+
+         else /* RGB bit_depth == 16 */
+         {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+            if (png_ptr->gamma_16_to_1 != NULL &&
+                png_ptr->gamma_16_from_1 != NULL)
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 red, green, blue, w;
+
+                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+
+                  if (red == green && red == blue)
+                     w = red;
+                  else
+                  {
+                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>
+                                  png_ptr->gamma_shift][red>>8];
+                     png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
+                                  png_ptr->gamma_shift][green>>8];
+                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>
+                                  png_ptr->gamma_shift][blue>>8];
+                     png_uint_16 gray16  = (png_uint_16)((rc*red_1 + gc*green_1
+                                  + bc*blue_1)>>15);
+                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
+                         png_ptr->gamma_shift][gray16 >> 8];
+                     rgb_error |= 1;
+                  }
+
+                  *(dp++) = (png_byte)((w>>8) & 0xff);
+                  *(dp++) = (png_byte)(w & 0xff);
+               }
+            }
+            else
+#endif
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 red, green, blue, gray16;
+
+                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+
+                  if (red != green || red != blue)
+                     rgb_error |= 1;
+                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
+                  *(dp++) = (png_byte)((gray16>>8) & 0xff);
+                  *(dp++) = (png_byte)(gray16 & 0xff);
+               }
+            }
+         }
+      }
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         if (row_info->bit_depth == 8)
+         {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];
+                  png_byte green = png_ptr->gamma_to_1[*(sp++)];
+                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];
+                  if (red != green || red != blue)
+                     rgb_error |= 1;
+                  *(dp++) =  png_ptr->gamma_from_1
+                             [(rc*red + gc*green + bc*blue)>>15];
+                  *(dp++) = *(sp++);  /* alpha */
+               }
+            }
+            else
+#endif
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_byte red   = *(sp++);
+                  png_byte green = *(sp++);
+                  png_byte blue  = *(sp++);
+                  if (red != green || red != blue)
+                     rgb_error |= 1;
+                  *(dp++) =  (png_byte)((rc*red + gc*green + bc*blue)>>15);
+                  *(dp++) = *(sp++);  /* alpha */
+               }
+            }
+         }
+         else /* RGBA bit_depth == 16 */
+         {
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+            if (png_ptr->gamma_16_to_1 != NULL &&
+                png_ptr->gamma_16_from_1 != NULL)
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 red, green, blue, w;
+
+                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
+
+                  if (red == green && red == blue)
+                     w = red;
+                  else
+                  {
+                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>
+                                  png_ptr->gamma_shift][red>>8];
+                     png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
+                                  png_ptr->gamma_shift][green>>8];
+                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>
+                                  png_ptr->gamma_shift][blue>>8];
+                     png_uint_16 gray16  = (png_uint_16)((rc * red_1
+                                  + gc * green_1 + bc * blue_1)>>15);
+                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
+                         png_ptr->gamma_shift][gray16 >> 8];
+                     rgb_error |= 1;
+                  }
+
+                  *(dp++) = (png_byte)((w>>8) & 0xff);
+                  *(dp++) = (png_byte)(w & 0xff);
+                  *(dp++) = *(sp++);  /* alpha */
+                  *(dp++) = *(sp++);
+               }
+            }
+            else
+#endif
+            {
+               png_bytep sp = row;
+               png_bytep dp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 red, green, blue, gray16;
+                  red   = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
+                  green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
+                  blue  = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
+                  if (red != green || red != blue)
+                     rgb_error |= 1;
+                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
+                  *(dp++) = (png_byte)((gray16>>8) & 0xff);
+                  *(dp++) = (png_byte)(gray16 & 0xff);
+                  *(dp++) = *(sp++);  /* alpha */
+                  *(dp++) = *(sp++);
+               }
+            }
+         }
+      }
+   row_info->channels -= (png_byte)2;
+      row_info->color_type &= ~PNG_COLOR_MASK_COLOR;
+      row_info->pixel_depth = (png_byte)(row_info->channels *
+         row_info->bit_depth);
+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+   }
+   return rgb_error;
+}
+#endif
+
+/* Build a grayscale palette.  Palette is assumed to be 1 << bit_depth
+ * large of png_color.  This lets grayscale images be treated as
+ * paletted.  Most useful for gamma correction and simplification
+ * of code.
+ */
+void PNGAPI
+png_build_grayscale_palette(int bit_depth, png_colorp palette)
+{
+   int num_palette;
+   int color_inc;
+   int i;
+   int v;
+
+   png_debug(1, "in png_do_build_grayscale_palette");
+
+   if (palette == NULL)
+      return;
+
+   switch (bit_depth)
+   {
+      case 1:
+         num_palette = 2;
+         color_inc = 0xff;
+         break;
+
+      case 2:
+         num_palette = 4;
+         color_inc = 0x55;
+         break;
+
+      case 4:
+         num_palette = 16;
+         color_inc = 0x11;
+         break;
+
+      case 8:
+         num_palette = 256;
+         color_inc = 1;
+         break;
+
+      default:
+         num_palette = 0;
+         color_inc = 0;
+         break;
+   }
+
+   for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
+   {
+      palette[i].red = (png_byte)v;
+      palette[i].green = (png_byte)v;
+      palette[i].blue = (png_byte)v;
+   }
+}
+
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+/* Replace any alpha or transparency with the supplied background color.
+ * "background" is already in the screen gamma, while "background_1" is
+ * at a gamma of 1.0.  Paletted files have already been taken care of.
+ */
+void /* PRIVATE */
+png_do_background(png_row_infop row_info, png_bytep row,
+   png_color_16p trans_color, png_color_16p background
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   , png_color_16p background_1,
+   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
+   png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
+   png_uint_16pp gamma_16_to_1, int gamma_shift
+#endif
+   )
+{
+   png_bytep sp, dp;
+   png_uint_32 i;
+   png_uint_32 row_width=row_info->width;
+   int shift;
+
+   png_debug(1, "in png_do_background");
+
+   if (background != NULL &&
+      (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
+      (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_color)))
+   {
+      switch (row_info->color_type)
+      {
+         case PNG_COLOR_TYPE_GRAY:
+         {
+            switch (row_info->bit_depth)
+            {
+               case 1:
+               {
+                  sp = row;
+                  shift = 7;
+                  for (i = 0; i < row_width; i++)
+                  {
+                     if ((png_uint_16)((*sp >> shift) & 0x01)
+                        == trans_color->gray)
+                     {
+                        *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
+                        *sp |= (png_byte)(background->gray << shift);
+                     }
+                     if (!shift)
+                     {
+                        shift = 7;
+                        sp++;
+                     }
+                     else
+                        shift--;
+                  }
+                  break;
+               }
+
+               case 2:
+               {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                  if (gamma_table != NULL)
+                  {
+                     sp = row;
+                     shift = 6;
+                     for (i = 0; i < row_width; i++)
+                     {
+                        if ((png_uint_16)((*sp >> shift) & 0x03)
+                            == trans_color->gray)
+                        {
+                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+                           *sp |= (png_byte)(background->gray << shift);
+                        }
+                        else
+                        {
+                           png_byte p = (png_byte)((*sp >> shift) & 0x03);
+                           png_byte g = (png_byte)((gamma_table [p | (p << 2) |
+                               (p << 4) | (p << 6)] >> 6) & 0x03);
+                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+                           *sp |= (png_byte)(g << shift);
+                        }
+                        if (!shift)
+                        {
+                           shift = 6;
+                           sp++;
+                        }
+                        else
+                           shift -= 2;
+                     }
+                  }
+                  else
+#endif
+                  {
+                     sp = row;
+                     shift = 6;
+                     for (i = 0; i < row_width; i++)
+                     {
+                        if ((png_uint_16)((*sp >> shift) & 0x03)
+                            == trans_color->gray)
+                        {
+                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+                           *sp |= (png_byte)(background->gray << shift);
+                        }
+                        if (!shift)
+                        {
+                           shift = 6;
+                           sp++;
+                        }
+                        else
+                           shift -= 2;
+                     }
+                  }
+                  break;
+               }
+
+               case 4:
+               {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                  if (gamma_table != NULL)
+                  {
+                     sp = row;
+                     shift = 4;
+                     for (i = 0; i < row_width; i++)
+                     {
+                        if ((png_uint_16)((*sp >> shift) & 0x0f)
+                            == trans_color->gray)
+                        {
+                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+                           *sp |= (png_byte)(background->gray << shift);
+                        }
+                        else
+                        {
+                           png_byte p = (png_byte)((*sp >> shift) & 0x0f);
+                           png_byte g = (png_byte)((gamma_table[p |
+                             (p << 4)] >> 4) & 0x0f);
+                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+                           *sp |= (png_byte)(g << shift);
+                        }
+                        if (!shift)
+                        {
+                           shift = 4;
+                           sp++;
+                        }
+                        else
+                           shift -= 4;
+                     }
+                  }
+                  else
+#endif
+                  {
+                     sp = row;
+                     shift = 4;
+                     for (i = 0; i < row_width; i++)
+                     {
+                        if ((png_uint_16)((*sp >> shift) & 0x0f)
+                            == trans_color->gray)
+                        {
+                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+                           *sp |= (png_byte)(background->gray << shift);
+                        }
+                        if (!shift)
+                        {
+                           shift = 4;
+                           sp++;
+                        }
+                        else
+                           shift -= 4;
+                     }
+                  }
+                  break;
+               }
+
+               case 8:
+               {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                  if (gamma_table != NULL)
+                  {
+                     sp = row;
+                     for (i = 0; i < row_width; i++, sp++)
+                     {
+                        if (*sp == trans_color->gray)
+                        {
+                           *sp = (png_byte)background->gray;
+                        }
+                        else
+                        {
+                           *sp = gamma_table[*sp];
+                        }
+                     }
+                  }
+                  else
+#endif
+                  {
+                     sp = row;
+                     for (i = 0; i < row_width; i++, sp++)
+                     {
+                        if (*sp == trans_color->gray)
+                        {
+                           *sp = (png_byte)background->gray;
+                        }
+                     }
+                  }
+                  break;
+               }
+
+               case 16:
+               {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                  if (gamma_16 != NULL)
+                  {
+                     sp = row;
+                     for (i = 0; i < row_width; i++, sp += 2)
+                     {
+                        png_uint_16 v;
+
+                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+                        if (v == trans_color->gray)
+                        {
+                           /* Background is already in screen gamma */
+                           *sp = (png_byte)((background->gray >> 8) & 0xff);
+                           *(sp + 1) = (png_byte)(background->gray & 0xff);
+                        }
+                        else
+                        {
+                           v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                           *sp = (png_byte)((v >> 8) & 0xff);
+                           *(sp + 1) = (png_byte)(v & 0xff);
+                        }
+                     }
+                  }
+                  else
+#endif
+                  {
+                     sp = row;
+                     for (i = 0; i < row_width; i++, sp += 2)
+                     {
+                        png_uint_16 v;
+
+                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+                        if (v == trans_color->gray)
+                        {
+                           *sp = (png_byte)((background->gray >> 8) & 0xff);
+                           *(sp + 1) = (png_byte)(background->gray & 0xff);
+                        }
+                     }
+                  }
+                  break;
+               }
+            }
+            break;
+         }
+
+         case PNG_COLOR_TYPE_RGB:
+         {
+            if (row_info->bit_depth == 8)
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_table != NULL)
+               {
+                  sp = row;
+                  for (i = 0; i < row_width; i++, sp += 3)
+                  {
+                     if (*sp == trans_color->red &&
+                        *(sp + 1) == trans_color->green &&
+                        *(sp + 2) == trans_color->blue)
+                     {
+                        *sp = (png_byte)background->red;
+                        *(sp + 1) = (png_byte)background->green;
+                        *(sp + 2) = (png_byte)background->blue;
+                     }
+                     else
+                     {
+                        *sp = gamma_table[*sp];
+                        *(sp + 1) = gamma_table[*(sp + 1)];
+                        *(sp + 2) = gamma_table[*(sp + 2)];
+                     }
+                  }
+               }
+               else
+#endif
+               {
+                  sp = row;
+                  for (i = 0; i < row_width; i++, sp += 3)
+                  {
+                     if (*sp == trans_color->red &&
+                        *(sp + 1) == trans_color->green &&
+                        *(sp + 2) == trans_color->blue)
+                     {
+                        *sp = (png_byte)background->red;
+                        *(sp + 1) = (png_byte)background->green;
+                        *(sp + 2) = (png_byte)background->blue;
+                     }
+                  }
+               }
+            }
+            else /* if (row_info->bit_depth == 16) */
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_16 != NULL)
+               {
+                  sp = row;
+                  for (i = 0; i < row_width; i++, sp += 6)
+                  {
+                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
+                     if (r == trans_color->red && g == trans_color->green &&
+                        b == trans_color->blue)
+                     {
+                        /* Background is already in screen gamma */
+                        *sp = (png_byte)((background->red >> 8) & 0xff);
+                        *(sp + 1) = (png_byte)(background->red & 0xff);
+                        *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
+                        *(sp + 3) = (png_byte)(background->green & 0xff);
+                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+                        *(sp + 5) = (png_byte)(background->blue & 0xff);
+                     }
+                     else
+                     {
+                        png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                        *sp = (png_byte)((v >> 8) & 0xff);
+                        *(sp + 1) = (png_byte)(v & 0xff);
+                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+                        *(sp + 2) = (png_byte)((v >> 8) & 0xff);
+                        *(sp + 3) = (png_byte)(v & 0xff);
+                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+                        *(sp + 4) = (png_byte)((v >> 8) & 0xff);
+                        *(sp + 5) = (png_byte)(v & 0xff);
+                     }
+                  }
+               }
+               else
+#endif
+               {
+                  sp = row;
+                  for (i = 0; i < row_width; i++, sp += 6)
+                  {
+                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));
+                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
+
+                     if (r == trans_color->red && g == trans_color->green &&
+                        b == trans_color->blue)
+                     {
+                        *sp = (png_byte)((background->red >> 8) & 0xff);
+                        *(sp + 1) = (png_byte)(background->red & 0xff);
+                        *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
+                        *(sp + 3) = (png_byte)(background->green & 0xff);
+                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+                        *(sp + 5) = (png_byte)(background->blue & 0xff);
+                     }
+                  }
+               }
+            }
+            break;
+         }
+
+         case PNG_COLOR_TYPE_GRAY_ALPHA:
+         {
+            if (row_info->bit_depth == 8)
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+                   gamma_table != NULL)
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 2, dp++)
+                  {
+                     png_uint_16 a = *(sp + 1);
+
+                     if (a == 0xff)
+                     {
+                        *dp = gamma_table[*sp];
+                     }
+                     else if (a == 0)
+                     {
+                        /* Background is already in screen gamma */
+                        *dp = (png_byte)background->gray;
+                     }
+                     else
+                     {
+                        png_byte v, w;
+
+                        v = gamma_to_1[*sp];
+                        png_composite(w, v, a, background_1->gray);
+                        *dp = gamma_from_1[w];
+                     }
+                  }
+               }
+               else
+#endif
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 2, dp++)
+                  {
+                     png_byte a = *(sp + 1);
+
+                     if (a == 0xff)
+                     {
+                        *dp = *sp;
+                     }
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                     else if (a == 0)
+                     {
+                        *dp = (png_byte)background->gray;
+                     }
+                     else
+                     {
+                        png_composite(*dp, *sp, a, background_1->gray);
+                     }
+#else
+                     *dp = (png_byte)background->gray;
+#endif
+                  }
+               }
+            }
+            else /* if (png_ptr->bit_depth == 16) */
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+                   gamma_16_to_1 != NULL)
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)
+                  {
+                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+
+                     if (a == (png_uint_16)0xffff)
+                     {
+                        png_uint_16 v;
+
+                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                        *dp = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(v & 0xff);
+                     }
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                     else if (a == 0)
+#else
+                     else
+#endif
+                     {
+                        /* Background is already in screen gamma */
+                        *dp = (png_byte)((background->gray >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(background->gray & 0xff);
+                     }
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                     else
+                     {
+                        png_uint_16 g, v, w;
+
+                        g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+                        png_composite_16(v, g, a, background_1->gray);
+                        w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];
+                        *dp = (png_byte)((w >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(w & 0xff);
+                     }
+#endif
+                  }
+               }
+               else
+#endif
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)
+                  {
+                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
+                     if (a == (png_uint_16)0xffff)
+                     {
+                        png_memcpy(dp, sp, 2);
+                     }
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                     else if (a == 0)
+#else
+                     else
+#endif
+                     {
+                        *dp = (png_byte)((background->gray >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(background->gray & 0xff);
+                     }
+#ifdef PNG_READ_GAMMA_SUPPORTED
+                     else
+                     {
+                        png_uint_16 g, v;
+
+                        g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+                        png_composite_16(v, g, a, background_1->gray);
+                        *dp = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(v & 0xff);
+                     }
+#endif
+                  }
+               }
+            }
+            break;
+         }
+
+         case PNG_COLOR_TYPE_RGB_ALPHA:
+         {
+            if (row_info->bit_depth == 8)
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+                   gamma_table != NULL)
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)
+                  {
+                     png_byte a = *(sp + 3);
+
+                     if (a == 0xff)
+                     {
+                        *dp = gamma_table[*sp];
+                        *(dp + 1) = gamma_table[*(sp + 1)];
+                        *(dp + 2) = gamma_table[*(sp + 2)];
+                     }
+                     else if (a == 0)
+                     {
+                        /* Background is already in screen gamma */
+                        *dp = (png_byte)background->red;
+                        *(dp + 1) = (png_byte)background->green;
+                        *(dp + 2) = (png_byte)background->blue;
+                     }
+                     else
+                     {
+                        png_byte v, w;
+
+                        v = gamma_to_1[*sp];
+                        png_composite(w, v, a, background_1->red);
+                        *dp = gamma_from_1[w];
+                        v = gamma_to_1[*(sp + 1)];
+                        png_composite(w, v, a, background_1->green);
+                        *(dp + 1) = gamma_from_1[w];
+                        v = gamma_to_1[*(sp + 2)];
+                        png_composite(w, v, a, background_1->blue);
+                        *(dp + 2) = gamma_from_1[w];
+                     }
+                  }
+               }
+               else
+#endif
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)
+                  {
+                     png_byte a = *(sp + 3);
+
+                     if (a == 0xff)
+                     {
+                        *dp = *sp;
+                        *(dp + 1) = *(sp + 1);
+                        *(dp + 2) = *(sp + 2);
+                     }
+                     else if (a == 0)
+                     {
+                        *dp = (png_byte)background->red;
+                        *(dp + 1) = (png_byte)background->green;
+                        *(dp + 2) = (png_byte)background->blue;
+                     }
+                     else
+                     {
+                        png_composite(*dp, *sp, a, background->red);
+                        png_composite(*(dp + 1), *(sp + 1), a,
+                           background->green);
+                        png_composite(*(dp + 2), *(sp + 2), a,
+                           background->blue);
+                     }
+                  }
+               }
+            }
+            else /* if (row_info->bit_depth == 16) */
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+                   gamma_16_to_1 != NULL)
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)
+                  {
+                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+                         << 8) + (png_uint_16)(*(sp + 7)));
+                     if (a == (png_uint_16)0xffff)
+                     {
+                        png_uint_16 v;
+
+                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                        *dp = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(v & 0xff);
+                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 3) = (png_byte)(v & 0xff);
+                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 5) = (png_byte)(v & 0xff);
+                     }
+                     else if (a == 0)
+                     {
+                        /* Background is already in screen gamma */
+                        *dp = (png_byte)((background->red >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(background->red & 0xff);
+                        *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
+                        *(dp + 3) = (png_byte)(background->green & 0xff);
+                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+                        *(dp + 5) = (png_byte)(background->blue & 0xff);
+                     }
+                     else
+                     {
+                        png_uint_16 v, w, x;
+
+                        v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+                        png_composite_16(w, v, a, background_1->red);
+                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
+                        *dp = (png_byte)((x >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(x & 0xff);
+                        v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
+                        png_composite_16(w, v, a, background_1->green);
+                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
+                        *(dp + 2) = (png_byte)((x >> 8) & 0xff);
+                        *(dp + 3) = (png_byte)(x & 0xff);
+                        v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
+                        png_composite_16(w, v, a, background_1->blue);
+                        x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];
+                        *(dp + 4) = (png_byte)((x >> 8) & 0xff);
+                        *(dp + 5) = (png_byte)(x & 0xff);
+                     }
+                  }
+               }
+               else
+#endif
+               {
+                  sp = row;
+                  dp = row;
+                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)
+                  {
+                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+                        << 8) + (png_uint_16)(*(sp + 7)));
+                     if (a == (png_uint_16)0xffff)
+                     {
+                        png_memcpy(dp, sp, 6);
+                     }
+                     else if (a == 0)
+                     {
+                        *dp = (png_byte)((background->red >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(background->red & 0xff);
+                        *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
+                        *(dp + 3) = (png_byte)(background->green & 0xff);
+                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
+                        *(dp + 5) = (png_byte)(background->blue & 0xff);
+                     }
+                     else
+                     {
+                        png_uint_16 v;
+
+                        png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+                        png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
+                            + *(sp + 3));
+                        png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
+                            + *(sp + 5));
+
+                        png_composite_16(v, r, a, background->red);
+                        *dp = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 1) = (png_byte)(v & 0xff);
+                        png_composite_16(v, g, a, background->green);
+                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 3) = (png_byte)(v & 0xff);
+                        png_composite_16(v, b, a, background->blue);
+                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);
+                        *(dp + 5) = (png_byte)(v & 0xff);
+                     }
+                  }
+               }
+            }
+            break;
+         }
+      }
+
+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
+      {
+         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
+         row_info->channels--;
+         row_info->pixel_depth = (png_byte)(row_info->channels *
+            row_info->bit_depth);
+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+      }
+   }
+}
+#endif
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+/* Gamma correct the image, avoiding the alpha channel.  Make sure
+ * you do this after you deal with the transparency issue on grayscale
+ * or RGB images. If your bit depth is 8, use gamma_table, if it
+ * is 16, use gamma_16_table and gamma_shift.  Build these with
+ * build_gamma_table().
+ */
+void /* PRIVATE */
+png_do_gamma(png_row_infop row_info, png_bytep row,
+   png_bytep gamma_table, png_uint_16pp gamma_16_table,
+   int gamma_shift)
+{
+   png_bytep sp;
+   png_uint_32 i;
+   png_uint_32 row_width=row_info->width;
+
+   png_debug(1, "in png_do_gamma");
+
+   if (
+       ((row_info->bit_depth <= 8 && gamma_table != NULL) ||
+        (row_info->bit_depth == 16 && gamma_16_table != NULL)))
+   {
+      switch (row_info->color_type)
+      {
+         case PNG_COLOR_TYPE_RGB:
+         {
+            if (row_info->bit_depth == 8)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  *sp = gamma_table[*sp];
+                  sp++;
+                  *sp = gamma_table[*sp];
+                  sp++;
+                  *sp = gamma_table[*sp];
+                  sp++;
+               }
+            }
+            else /* if (row_info->bit_depth == 16) */
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 v;
+
+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 2;
+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 2;
+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 2;
+               }
+            }
+            break;
+         }
+
+         case PNG_COLOR_TYPE_RGB_ALPHA:
+         {
+            if (row_info->bit_depth == 8)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  *sp = gamma_table[*sp];
+                  sp++;
+                  *sp = gamma_table[*sp];
+                  sp++;
+                  *sp = gamma_table[*sp];
+                  sp++;
+                  sp++;
+               }
+            }
+            else /* if (row_info->bit_depth == 16) */
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 2;
+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 2;
+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 4;
+               }
+            }
+            break;
+         }
+
+         case PNG_COLOR_TYPE_GRAY_ALPHA:
+         {
+            if (row_info->bit_depth == 8)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  *sp = gamma_table[*sp];
+                  sp += 2;
+               }
+            }
+            else /* if (row_info->bit_depth == 16) */
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 4;
+               }
+            }
+            break;
+         }
+
+         case PNG_COLOR_TYPE_GRAY:
+         {
+            if (row_info->bit_depth == 2)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i += 4)
+               {
+                  int a = *sp & 0xc0;
+                  int b = *sp & 0x30;
+                  int c = *sp & 0x0c;
+                  int d = *sp & 0x03;
+
+                  *sp = (png_byte)(
+                        ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)])   ) & 0xc0)|
+                        ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|
+                        ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|
+                        ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));
+                  sp++;
+               }
+            }
+
+            if (row_info->bit_depth == 4)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i += 2)
+               {
+                  int msb = *sp & 0xf0;
+                  int lsb = *sp & 0x0f;
+
+                  *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)
+                          | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));
+                  sp++;
+               }
+            }
+
+            else if (row_info->bit_depth == 8)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  *sp = gamma_table[*sp];
+                  sp++;
+               }
+            }
+
+            else if (row_info->bit_depth == 16)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++)
+               {
+                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
+                  *sp = (png_byte)((v >> 8) & 0xff);
+                  *(sp + 1) = (png_byte)(v & 0xff);
+                  sp += 2;
+               }
+            }
+            break;
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* Expands a palette row to an RGB or RGBA row depending
+ * upon whether you supply trans and num_trans.
+ */
+void /* PRIVATE */
+png_do_expand_palette(png_row_infop row_info, png_bytep row,
+   png_colorp palette, png_bytep trans_alpha, int num_trans)
+{
+   int shift, value;
+   png_bytep sp, dp;
+   png_uint_32 i;
+   png_uint_32 row_width=row_info->width;
+
+   png_debug(1, "in png_do_expand_palette");
+
+   if (
+       row_info->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (row_info->bit_depth < 8)
+      {
+         switch (row_info->bit_depth)
+         {
+            case 1:
+            {
+               sp = row + (png_size_t)((row_width - 1) >> 3);
+               dp = row + (png_size_t)row_width - 1;
+               shift = 7 - (int)((row_width + 7) & 0x07);
+               for (i = 0; i < row_width; i++)
+               {
+                  if ((*sp >> shift) & 0x01)
+                     *dp = 1;
+                  else
+                     *dp = 0;
+                  if (shift == 7)
+                  {
+                     shift = 0;
+                     sp--;
+                  }
+                  else
+                     shift++;
+
+                  dp--;
+               }
+               break;
+            }
+
+            case 2:
+            {
+               sp = row + (png_size_t)((row_width - 1) >> 2);
+               dp = row + (png_size_t)row_width - 1;
+               shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+               for (i = 0; i < row_width; i++)
+               {
+                  value = (*sp >> shift) & 0x03;
+                  *dp = (png_byte)value;
+                  if (shift == 6)
+                  {
+                     shift = 0;
+                     sp--;
+                  }
+                  else
+                     shift += 2;
+
+                  dp--;
+               }
+               break;
+            }
+
+            case 4:
+            {
+               sp = row + (png_size_t)((row_width - 1) >> 1);
+               dp = row + (png_size_t)row_width - 1;
+               shift = (int)((row_width & 0x01) << 2);
+               for (i = 0; i < row_width; i++)
+               {
+                  value = (*sp >> shift) & 0x0f;
+                  *dp = (png_byte)value;
+                  if (shift == 4)
+                  {
+                     shift = 0;
+                     sp--;
+                  }
+                  else
+                     shift += 4;
+
+                  dp--;
+               }
+               break;
+            }
+         }
+         row_info->bit_depth = 8;
+         row_info->pixel_depth = 8;
+         row_info->rowbytes = row_width;
+      }
+      switch (row_info->bit_depth)
+      {
+         case 8:
+         {
+            if (trans_alpha != NULL)
+            {
+               sp = row + (png_size_t)row_width - 1;
+               dp = row + (png_size_t)(row_width << 2) - 1;
+
+               for (i = 0; i < row_width; i++)
+               {
+                  if ((int)(*sp) >= num_trans)
+                     *dp-- = 0xff;
+                  else
+                     *dp-- = trans_alpha[*sp];
+                  *dp-- = palette[*sp].blue;
+                  *dp-- = palette[*sp].green;
+                  *dp-- = palette[*sp].red;
+                  sp--;
+               }
+               row_info->bit_depth = 8;
+               row_info->pixel_depth = 32;
+               row_info->rowbytes = row_width * 4;
+               row_info->color_type = 6;
+               row_info->channels = 4;
+            }
+            else
+            {
+               sp = row + (png_size_t)row_width - 1;
+               dp = row + (png_size_t)(row_width * 3) - 1;
+
+               for (i = 0; i < row_width; i++)
+               {
+                  *dp-- = palette[*sp].blue;
+                  *dp-- = palette[*sp].green;
+                  *dp-- = palette[*sp].red;
+                  sp--;
+               }
+
+               row_info->bit_depth = 8;
+               row_info->pixel_depth = 24;
+               row_info->rowbytes = row_width * 3;
+               row_info->color_type = 2;
+               row_info->channels = 3;
+            }
+            break;
+         }
+      }
+   }
+}
+
+/* If the bit depth < 8, it is expanded to 8.  Also, if the already
+ * expanded transparency value is supplied, an alpha channel is built.
+ */
+void /* PRIVATE */
+png_do_expand(png_row_infop row_info, png_bytep row,
+   png_color_16p trans_value)
+{
+   int shift, value;
+   png_bytep sp, dp;
+   png_uint_32 i;
+   png_uint_32 row_width=row_info->width;
+
+   png_debug(1, "in png_do_expand");
+
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+      {
+         png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);
+
+         if (row_info->bit_depth < 8)
+         {
+            switch (row_info->bit_depth)
+            {
+               case 1:
+               {
+                  gray = (png_uint_16)((gray&0x01)*0xff);
+                  sp = row + (png_size_t)((row_width - 1) >> 3);
+                  dp = row + (png_size_t)row_width - 1;
+                  shift = 7 - (int)((row_width + 7) & 0x07);
+                  for (i = 0; i < row_width; i++)
+                  {
+                     if ((*sp >> shift) & 0x01)
+                        *dp = 0xff;
+                     else
+                        *dp = 0;
+                     if (shift == 7)
+                     {
+                        shift = 0;
+                        sp--;
+                     }
+                     else
+                        shift++;
+
+                     dp--;
+                  }
+                  break;
+               }
+
+               case 2:
+               {
+                  gray = (png_uint_16)((gray&0x03)*0x55);
+                  sp = row + (png_size_t)((row_width - 1) >> 2);
+                  dp = row + (png_size_t)row_width - 1;
+                  shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+                  for (i = 0; i < row_width; i++)
+                  {
+                     value = (*sp >> shift) & 0x03;
+                     *dp = (png_byte)(value | (value << 2) | (value << 4) |
+                        (value << 6));
+                     if (shift == 6)
+                     {
+                        shift = 0;
+                        sp--;
+                     }
+                     else
+                        shift += 2;
+
+                     dp--;
+                  }
+                  break;
+               }
+
+               case 4:
+               {
+                  gray = (png_uint_16)((gray&0x0f)*0x11);
+                  sp = row + (png_size_t)((row_width - 1) >> 1);
+                  dp = row + (png_size_t)row_width - 1;
+                  shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
+                  for (i = 0; i < row_width; i++)
+                  {
+                     value = (*sp >> shift) & 0x0f;
+                     *dp = (png_byte)(value | (value << 4));
+                     if (shift == 4)
+                     {
+                        shift = 0;
+                        sp--;
+                     }
+                     else
+                        shift = 4;
+
+                     dp--;
+                  }
+                  break;
+               }
+            }
+
+            row_info->bit_depth = 8;
+            row_info->pixel_depth = 8;
+            row_info->rowbytes = row_width;
+         }
+
+         if (trans_value != NULL)
+         {
+            if (row_info->bit_depth == 8)
+            {
+               gray = gray & 0xff;
+               sp = row + (png_size_t)row_width - 1;
+               dp = row + (png_size_t)(row_width << 1) - 1;
+               for (i = 0; i < row_width; i++)
+               {
+                  if (*sp == gray)
+                     *dp-- = 0;
+                  else
+                     *dp-- = 0xff;
+                  *dp-- = *sp--;
+               }
+            }
+
+            else if (row_info->bit_depth == 16)
+            {
+               png_byte gray_high = (gray >> 8) & 0xff;
+               png_byte gray_low = gray & 0xff;
+               sp = row + row_info->rowbytes - 1;
+               dp = row + (row_info->rowbytes << 1) - 1;
+               for (i = 0; i < row_width; i++)
+               {
+                  if (*(sp - 1) == gray_high && *(sp) == gray_low)
+                  {
+                     *dp-- = 0;
+                     *dp-- = 0;
+                  }
+                  else
+                  {
+                     *dp-- = 0xff;
+                     *dp-- = 0xff;
+                  }
+                  *dp-- = *sp--;
+                  *dp-- = *sp--;
+               }
+            }
+
+            row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+            row_info->channels = 2;
+            row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
+            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
+               row_width);
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)
+      {
+         if (row_info->bit_depth == 8)
+         {
+            png_byte red = trans_value->red & 0xff;
+            png_byte green = trans_value->green & 0xff;
+            png_byte blue = trans_value->blue & 0xff;
+            sp = row + (png_size_t)row_info->rowbytes - 1;
+            dp = row + (png_size_t)(row_width << 2) - 1;
+            for (i = 0; i < row_width; i++)
+            {
+               if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
+                  *dp-- = 0;
+               else
+                  *dp-- = 0xff;
+               *dp-- = *sp--;
+               *dp-- = *sp--;
+               *dp-- = *sp--;
+            }
+         }
+         else if (row_info->bit_depth == 16)
+         {
+            png_byte red_high = (trans_value->red >> 8) & 0xff;
+            png_byte green_high = (trans_value->green >> 8) & 0xff;
+            png_byte blue_high = (trans_value->blue >> 8) & 0xff;
+            png_byte red_low = trans_value->red & 0xff;
+            png_byte green_low = trans_value->green & 0xff;
+            png_byte blue_low = trans_value->blue & 0xff;
+            sp = row + row_info->rowbytes - 1;
+            dp = row + (png_size_t)(row_width << 3) - 1;
+            for (i = 0; i < row_width; i++)
+            {
+               if (*(sp - 5) == red_high &&
+                  *(sp - 4) == red_low &&
+                  *(sp - 3) == green_high &&
+                  *(sp - 2) == green_low &&
+                  *(sp - 1) == blue_high &&
+                  *(sp    ) == blue_low)
+               {
+                  *dp-- = 0;
+                  *dp-- = 0;
+               }
+               else
+               {
+                  *dp-- = 0xff;
+                  *dp-- = 0xff;
+               }
+               *dp-- = *sp--;
+               *dp-- = *sp--;
+               *dp-- = *sp--;
+               *dp-- = *sp--;
+               *dp-- = *sp--;
+               *dp-- = *sp--;
+            }
+         }
+         row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+         row_info->channels = 4;
+         row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+      }
+   }
+}
+#endif
+
+#ifdef PNG_READ_DITHER_SUPPORTED
+void /* PRIVATE */
+png_do_dither(png_row_infop row_info, png_bytep row,
+    png_bytep palette_lookup, png_bytep dither_lookup)
+{
+   png_bytep sp, dp;
+   png_uint_32 i;
+   png_uint_32 row_width=row_info->width;
+
+   png_debug(1, "in png_do_dither");
+
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
+         palette_lookup && row_info->bit_depth == 8)
+      {
+         int r, g, b, p;
+         sp = row;
+         dp = row;
+         for (i = 0; i < row_width; i++)
+         {
+            r = *sp++;
+            g = *sp++;
+            b = *sp++;
+
+            /* This looks real messy, but the compiler will reduce
+             * it down to a reasonable formula.  For example, with
+             * 5 bits per color, we get:
+             * p = (((r >> 3) & 0x1f) << 10) |
+             *    (((g >> 3) & 0x1f) << 5) |
+             *    ((b >> 3) & 0x1f);
+             */
+            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
+               ((1 << PNG_DITHER_RED_BITS) - 1)) <<
+               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
+               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
+               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
+               (PNG_DITHER_BLUE_BITS)) |
+               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
+               ((1 << PNG_DITHER_BLUE_BITS) - 1));
+
+            *dp++ = palette_lookup[p];
+         }
+         row_info->color_type = PNG_COLOR_TYPE_PALETTE;
+         row_info->channels = 1;
+         row_info->pixel_depth = row_info->bit_depth;
+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
+         palette_lookup != NULL && row_info->bit_depth == 8)
+      {
+         int r, g, b, p;
+         sp = row;
+         dp = row;
+         for (i = 0; i < row_width; i++)
+         {
+            r = *sp++;
+            g = *sp++;
+            b = *sp++;
+            sp++;
+
+            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
+               ((1 << PNG_DITHER_RED_BITS) - 1)) <<
+               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
+               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
+               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
+               (PNG_DITHER_BLUE_BITS)) |
+               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
+               ((1 << PNG_DITHER_BLUE_BITS) - 1));
+
+            *dp++ = palette_lookup[p];
+         }
+         row_info->color_type = PNG_COLOR_TYPE_PALETTE;
+         row_info->channels = 1;
+         row_info->pixel_depth = row_info->bit_depth;
+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
+         dither_lookup && row_info->bit_depth == 8)
+      {
+         sp = row;
+         for (i = 0; i < row_width; i++, sp++)
+         {
+            *sp = dither_lookup[*sp];
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+#ifdef PNG_READ_GAMMA_SUPPORTED
+static PNG_CONST int png_gamma_shift[] =
+   {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};
+
+/* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit
+ * tables, we don't make a full table if we are reducing to 8-bit in
+ * the future.  Note also how the gamma_16 tables are segmented so that
+ * we don't need to allocate > 64K chunks for a full 16-bit table.
+ *
+ * See the PNG extensions document for an integer algorithm for creating
+ * the gamma tables.  Maybe we will implement that here someday.
+ *
+ * We should only reach this point if
+ *
+ *      the file_gamma is known (i.e., the gAMA or sRGB chunk is present,
+ *      or the application has provided a file_gamma)
+ *
+ *   AND
+ *      {
+ *         the screen_gamma is known
+ *
+ *      OR
+ *
+ *         RGB_to_gray transformation is being performed
+ *      }
+ *
+ *   AND
+ *      {
+ *         the screen_gamma is different from the reciprocal of the
+ *         file_gamma by more than the specified threshold
+ *
+ *      OR
+ *
+ *         a background color has been specified and the file_gamma
+ *         and screen_gamma are not 1.0, within the specified threshold.
+ *      }
+ */
+
+void /* PRIVATE */
+png_build_gamma_table(png_structp png_ptr, png_byte bit_depth)
+{
+  png_debug(1, "in png_build_gamma_table");
+
+  if (bit_depth <= 8)
+  {
+     int i;
+     double g;
+
+     if (png_ptr->screen_gamma > .000001)
+        g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+
+     else
+        g = 1.0;
+
+     png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,
+        (png_uint_32)256);
+
+     for (i = 0; i < 256; i++)
+     {
+        png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,
+           g) * 255.0 + .5);
+     }
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+     if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))
+     {
+
+        g = 1.0 / (png_ptr->gamma);
+
+        png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,
+           (png_uint_32)256);
+
+        for (i = 0; i < 256; i++)
+        {
+           png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,
+              g) * 255.0 + .5);
+        }
+
+
+        png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,
+           (png_uint_32)256);
+
+        if (png_ptr->screen_gamma > 0.000001)
+           g = 1.0 / png_ptr->screen_gamma;
+
+        else
+           g = png_ptr->gamma;   /* Probably doing rgb_to_gray */
+
+        for (i = 0; i < 256; i++)
+        {
+           png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,
+              g) * 255.0 + .5);
+
+        }
+     }
+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
+  }
+  else
+  {
+     double g;
+     int i, j, shift, num;
+     int sig_bit;
+     png_uint_32 ig;
+
+     if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
+     {
+        sig_bit = (int)png_ptr->sig_bit.red;
+
+        if ((int)png_ptr->sig_bit.green > sig_bit)
+           sig_bit = png_ptr->sig_bit.green;
+
+        if ((int)png_ptr->sig_bit.blue > sig_bit)
+           sig_bit = png_ptr->sig_bit.blue;
+     }
+     else
+     {
+        sig_bit = (int)png_ptr->sig_bit.gray;
+     }
+
+     if (sig_bit > 0)
+        shift = 16 - sig_bit;
+
+     else
+        shift = 0;
+
+     if (png_ptr->transformations & PNG_16_TO_8)
+     {
+        if (shift < (16 - PNG_MAX_GAMMA_8))
+           shift = (16 - PNG_MAX_GAMMA_8);
+     }
+
+     if (shift > 8)
+        shift = 8;
+
+     if (shift < 0)
+        shift = 0;
+
+     png_ptr->gamma_shift = (png_byte)shift;
+
+     num = (1 << (8 - shift));
+
+     if (png_ptr->screen_gamma > .000001)
+        g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+     else
+        g = 1.0;
+
+     png_ptr->gamma_16_table = (png_uint_16pp)png_calloc(png_ptr,
+        (png_uint_32)(num * png_sizeof(png_uint_16p)));
+
+     if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
+     {
+        double fin, fout;
+        png_uint_32 last, max;
+
+        for (i = 0; i < num; i++)
+        {
+           png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
+              (png_uint_32)(256 * png_sizeof(png_uint_16)));
+        }
+
+        g = 1.0 / g;
+        last = 0;
+        for (i = 0; i < 256; i++)
+        {
+           fout = ((double)i + 0.5) / 256.0;
+           fin = pow(fout, g);
+           max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));
+           while (last <= max)
+           {
+              png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
+                 [(int)(last >> (8 - shift))] = (png_uint_16)(
+                 (png_uint_16)i | ((png_uint_16)i << 8));
+              last++;
+           }
+        }
+        while (last < ((png_uint_32)num << 8))
+        {
+           png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
+              [(int)(last >> (8 - shift))] = (png_uint_16)65535L;
+           last++;
+        }
+     }
+     else
+     {
+        for (i = 0; i < num; i++)
+        {
+           png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
+              (png_uint_32)(256 * png_sizeof(png_uint_16)));
+
+           ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
+
+           for (j = 0; j < 256; j++)
+           {
+              png_ptr->gamma_16_table[i][j] =
+                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
+                    65535.0, g) * 65535.0 + .5);
+           }
+        }
+     }
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+     if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
+     {
+
+        g = 1.0 / (png_ptr->gamma);
+
+        png_ptr->gamma_16_to_1 = (png_uint_16pp)png_calloc(png_ptr,
+           (png_uint_32)(num * png_sizeof(png_uint_16p )));
+
+        for (i = 0; i < num; i++)
+        {
+           png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
+              (png_uint_32)(256 * png_sizeof(png_uint_16)));
+
+           ig = (((png_uint_32)i *
+              (png_uint_32)png_gamma_shift[shift]) >> 4);
+           for (j = 0; j < 256; j++)
+           {
+              png_ptr->gamma_16_to_1[i][j] =
+                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
+                    65535.0, g) * 65535.0 + .5);
+           }
+        }
+
+        if (png_ptr->screen_gamma > 0.000001)
+           g = 1.0 / png_ptr->screen_gamma;
+
+        else
+           g = png_ptr->gamma;   /* Probably doing rgb_to_gray */
+
+        png_ptr->gamma_16_from_1 = (png_uint_16pp)png_calloc(png_ptr,
+           (png_uint_32)(num * png_sizeof(png_uint_16p)));
+
+        for (i = 0; i < num; i++)
+        {
+           png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
+              (png_uint_32)(256 * png_sizeof(png_uint_16)));
+
+           ig = (((png_uint_32)i *
+              (png_uint_32)png_gamma_shift[shift]) >> 4);
+
+           for (j = 0; j < 256; j++)
+           {
+              png_ptr->gamma_16_from_1[i][j] =
+                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
+                    65535.0, g) * 65535.0 + .5);
+           }
+        }
+     }
+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
+  }
+}
+#endif
+/* To do: install integer version of png_build_gamma_table here */
+#endif
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+/* Undoes intrapixel differencing  */
+void /* PRIVATE */
+png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_read_intrapixel");
+
+   if (
+       (row_info->color_type & PNG_COLOR_MASK_COLOR))
+   {
+      int bytes_per_pixel;
+      png_uint_32 row_width = row_info->width;
+      if (row_info->bit_depth == 8)
+      {
+         png_bytep rp;
+         png_uint_32 i;
+
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+            bytes_per_pixel = 3;
+
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+            bytes_per_pixel = 4;
+
+         else
+            return;
+
+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+         {
+            *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);
+            *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);
+         }
+      }
+      else if (row_info->bit_depth == 16)
+      {
+         png_bytep rp;
+         png_uint_32 i;
+
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+            bytes_per_pixel = 6;
+
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+            bytes_per_pixel = 8;
+
+         else
+            return;
+
+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+         {
+            png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
+            png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
+            png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
+            png_uint_32 red  = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);
+            png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);
+            *(rp  ) = (png_byte)((red >> 8) & 0xff);
+            *(rp+1) = (png_byte)(red & 0xff);
+            *(rp+4) = (png_byte)((blue >> 8) & 0xff);
+            *(rp+5) = (png_byte)(blue & 0xff);
+         }
+      }
+   }
+}
+#endif /* PNG_MNG_FEATURES_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED */
diff --git a/src/libpng/pngrutil.c b/src/libpng/pngrutil.c
index 61bfe60ea..d971e8f18 100644
--- a/src/libpng/pngrutil.c
+++ b/src/libpng/pngrutil.c
@@ -1,3243 +1,3336 @@
-

-/* pngrutil.c - utilities to read a PNG file

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This file contains routines that are only called from within

- * libpng itself during the course of reading an image.

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_READ_SUPPORTED

-

-#if defined(_WIN32_WCE) && (_WIN32_WCE<0x500)

-#  define WIN32_WCE_OLD

-#endif

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-#  ifdef WIN32_WCE_OLD

-/* The strtod() function is not supported on WindowsCE */

-__inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, char **endptr)

-{

-   double result = 0;

-   int len;

-   wchar_t *str, *end;

-

-   len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0);

-   str = (wchar_t *)png_malloc(png_ptr, len * png_sizeof(wchar_t));

-   if ( NULL != str )

-   {

-      MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len);

-      result = wcstod(str, &end);

-      len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL);

-      *endptr = (char *)nptr + (png_strlen(nptr) - len + 1);

-      png_free(png_ptr, str);

-   }

-   return result;

-}

-#  else

-#    define png_strtod(p,a,b) strtod(a,b)

-#  endif

-#endif

-

-png_uint_32 PNGAPI

-png_get_uint_31(png_structp png_ptr, png_bytep buf)

-{

-#ifdef PNG_READ_BIG_ENDIAN_SUPPORTED

-   png_uint_32 i = png_get_uint_32(buf);

-#else

-   /* Avoid an extra function call by inlining the result. */

-   png_uint_32 i = ((png_uint_32)(*buf) << 24) +

-      ((png_uint_32)(*(buf + 1)) << 16) +

-      ((png_uint_32)(*(buf + 2)) << 8) +

-      (png_uint_32)(*(buf + 3));

-#endif

-   if (i > PNG_UINT_31_MAX)

-     png_error(png_ptr, "PNG unsigned integer out of range.");

-   return (i);

-}

-#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED

-/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */

-png_uint_32 PNGAPI

-png_get_uint_32(png_bytep buf)

-{

-   png_uint_32 i = ((png_uint_32)(*buf) << 24) +

-      ((png_uint_32)(*(buf + 1)) << 16) +

-      ((png_uint_32)(*(buf + 2)) << 8) +

-      (png_uint_32)(*(buf + 3));

-

-   return (i);

-}

-

-/* 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

- * assumed that the machine format for signed integers is the same.

- */

-png_int_32 PNGAPI

-png_get_int_32(png_bytep buf)

-{

-   png_int_32 i = ((png_int_32)(*buf) << 24) +

-      ((png_int_32)(*(buf + 1)) << 16) +

-      ((png_int_32)(*(buf + 2)) << 8) +

-      (png_int_32)(*(buf + 3));

-

-   return (i);

-}

-

-/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */

-png_uint_16 PNGAPI

-png_get_uint_16(png_bytep buf)

-{

-   png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +

-      (png_uint_16)(*(buf + 1)));

-

-   return (i);

-}

-#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */

-

-/* Read the chunk header (length + type name).

- * Put the type name into png_ptr->chunk_name, and return the length.

- */

-png_uint_32 /* PRIVATE */

-png_read_chunk_header(png_structp png_ptr)

-{

-   png_byte buf[8];

-   png_uint_32 length;

-

-   /* Read the length and the chunk name */

-   png_read_data(png_ptr, buf, 8);

-   length = png_get_uint_31(png_ptr, buf);

-

-   /* Put the chunk name into png_ptr->chunk_name */

-   png_memcpy(png_ptr->chunk_name, buf + 4, 4);

-

-   png_debug2(0, "Reading %s chunk, length = %lu",

-      png_ptr->chunk_name, length);

-

-   /* Reset the crc and run it over the chunk name */

-   png_reset_crc(png_ptr);

-   png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);

-

-   /* Check to see if chunk name is valid */

-   png_check_chunk_name(png_ptr, png_ptr->chunk_name);

-

-   return length;

-}

-

-/* Read data, and (optionally) run it through the CRC. */

-void /* PRIVATE */

-png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)

-{

-   if (png_ptr == NULL)

-      return;

-   png_read_data(png_ptr, buf, length);

-   png_calculate_crc(png_ptr, buf, length);

-}

-

-/* 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

- * things up, we may calculate the CRC on the data and print a message.

- * Returns '1' if there was a CRC error, '0' otherwise.

- */

-int /* PRIVATE */

-png_crc_finish(png_structp png_ptr, png_uint_32 skip)

-{

-   png_size_t i;

-   png_size_t istop = png_ptr->zbuf_size;

-

-   for (i = (png_size_t)skip; i > istop; i -= istop)

-   {

-      png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

-   }

-   if (i)

-   {

-      png_crc_read(png_ptr, png_ptr->zbuf, i);

-   }

-

-   if (png_crc_error(png_ptr))

-   {

-      if (((png_ptr->chunk_name[0] & 0x20) &&                /* Ancillary */

-          !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||

-          (!(png_ptr->chunk_name[0] & 0x20) &&             /* Critical  */

-          (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))

-      {

-         png_chunk_warning(png_ptr, "CRC error");

-      }

-      else

-      {

-         png_chunk_error(png_ptr, "CRC error");

-      }

-      return (1);

-   }

-

-   return (0);

-}

-

-/* Compare the CRC stored in the PNG file with that calculated by libpng from

- * the data it has read thus far.

- */

-int /* PRIVATE */

-png_crc_error(png_structp png_ptr)

-{

-   png_byte crc_bytes[4];

-   png_uint_32 crc;

-   int need_crc = 1;

-

-   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */

-   {

-      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

-          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

-         need_crc = 0;

-   }

-   else                                                    /* critical */

-   {

-      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

-         need_crc = 0;

-   }

-

-   png_read_data(png_ptr, crc_bytes, 4);

-

-   if (need_crc)

-   {

-      crc = png_get_uint_32(crc_bytes);

-      return ((int)(crc != png_ptr->crc));

-   }

-   else

-      return (0);

-}

-

-#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \

-    defined(PNG_READ_iCCP_SUPPORTED)

-/*

- * Decompress trailing data in a chunk.  The assumption is that chunkdata

- * points at an allocated area holding the contents of a chunk with a

- * trailing compressed part.  What we get back is an allocated area

- * holding the original prefix part and an uncompressed version of the

- * trailing part (the malloc area passed in is freed).

- */

-void /* PRIVATE */

-png_decompress_chunk(png_structp png_ptr, int comp_type,

-                              png_size_t chunklength,

-                              png_size_t prefix_size, png_size_t *newlength)

-{

-   static PNG_CONST char msg[] = "Error decoding compressed chunk";

-   png_charp text;

-   png_size_t text_size;

-

-   if (comp_type == PNG_COMPRESSION_TYPE_BASE)

-   {

-      int ret = Z_OK;

-      png_ptr->zstream.next_in = (png_bytep)(png_ptr->chunkdata + prefix_size);

-      png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size);

-      png_ptr->zstream.next_out = png_ptr->zbuf;

-      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-

-      text_size = 0;

-      text = NULL;

-

-      while (png_ptr->zstream.avail_in)

-      {

-         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-         if (ret != Z_OK && ret != Z_STREAM_END)

-         {

-            if (png_ptr->zstream.msg != NULL)

-               png_warning(png_ptr, png_ptr->zstream.msg);

-            else

-               png_warning(png_ptr, msg);

-            inflateReset(&png_ptr->zstream);

-            png_ptr->zstream.avail_in = 0;

-

-            if (text ==  NULL)

-            {

-               text_size = prefix_size + png_sizeof(msg) + 1;

-               text = (png_charp)png_malloc_warn(png_ptr, text_size);

-               if (text ==  NULL)

-                 {

-                    png_free(png_ptr, png_ptr->chunkdata);

-                    png_ptr->chunkdata = NULL;

-                    png_error(png_ptr, "Not enough memory to decompress chunk");

-                 }

-               png_memcpy(text, png_ptr->chunkdata, prefix_size);

-            }

-

-            text[text_size - 1] = 0x00;

-

-            /* Copy what we can of the error message into the text chunk */

-            text_size = (png_size_t)(chunklength -

-              (text - png_ptr->chunkdata) - 1);

-            if (text_size > png_sizeof(msg))

-               text_size = png_sizeof(msg);

-            png_memcpy(text + prefix_size, msg, text_size);

-            break;

-         }

-         if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END)

-         {

-            if (text == NULL)

-            {

-               text_size = prefix_size +

-                   png_ptr->zbuf_size - png_ptr->zstream.avail_out;

-               text = (png_charp)png_malloc_warn(png_ptr, text_size + 1);

-               if (text ==  NULL)

-               {

-                  png_free(png_ptr, png_ptr->chunkdata);

-                  png_ptr->chunkdata = NULL;

-                  png_error(png_ptr,

-                    "Not enough memory to decompress chunk.");

-               }

-               png_memcpy(text + prefix_size, png_ptr->zbuf,

-                    text_size - prefix_size);

-               png_memcpy(text, png_ptr->chunkdata, prefix_size);

-               *(text + text_size) = 0x00;

-            }

-            else

-            {

-               png_charp tmp;

-

-               tmp = text;

-                  text = (png_charp)png_malloc_warn(png_ptr,

-                     (png_uint_32)(text_size +

-                      png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1));

-               if (text == NULL)

-               {

-                  png_free(png_ptr, tmp);

-                  png_free(png_ptr, png_ptr->chunkdata);

-                  png_ptr->chunkdata = NULL;

-                  png_error(png_ptr,

-                    "Not enough memory to decompress chunk..");

-               }

-               png_memcpy(text, tmp, text_size);

-               png_free(png_ptr, tmp);

-               png_memcpy(text + text_size, png_ptr->zbuf,

-                  (png_ptr->zbuf_size - png_ptr->zstream.avail_out));

-               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;

-               *(text + text_size) = 0x00;

-            }

-            if (ret == Z_STREAM_END)

-               break;

-            else

-            {

-               png_ptr->zstream.next_out = png_ptr->zbuf;

-               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-            }

-         }

-      }

-      if (ret != Z_STREAM_END)

-      {

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-         char umsg[52];

-

-         if (ret == Z_BUF_ERROR)

-            png_snprintf(umsg, 52,

-                "Buffer error in compressed datastream in %s chunk",

-                png_ptr->chunk_name);

-

-         else if (ret == Z_DATA_ERROR)

-            png_snprintf(umsg, 52,

-                "Data error in compressed datastream in %s chunk",

-                png_ptr->chunk_name);

-

-         else

-            png_snprintf(umsg, 52,

-                "Incomplete compressed datastream in %s chunk",

-                png_ptr->chunk_name);

-

-         png_warning(png_ptr, umsg);

-#else

-         png_warning(png_ptr,

-            "Incomplete compressed datastream in chunk other than IDAT");

-#endif

-         text_size = prefix_size;

-         if (text ==  NULL)

-         {

-            text = (png_charp)png_malloc_warn(png_ptr, text_size+1);

-            if (text == NULL)

-              {

-                png_free(png_ptr, png_ptr->chunkdata);

-                png_ptr->chunkdata = NULL;

-                png_error(png_ptr, "Not enough memory for text.");

-              }

-            png_memcpy(text, png_ptr->chunkdata, prefix_size);

-         }

-         *(text + text_size) = 0x00;

-      }

-

-      inflateReset(&png_ptr->zstream);

-      png_ptr->zstream.avail_in = 0;

-

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = text;

-      *newlength=text_size;

-   }

-   else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */

-   {

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-      char umsg[50];

-

-      png_snprintf(umsg, 50, "Unknown zTXt compression type %d", comp_type);

-      png_warning(png_ptr, umsg);

-#else

-      png_warning(png_ptr, "Unknown zTXt compression type");

-#endif

-

-      *(png_ptr->chunkdata + prefix_size) = 0x00;

-      *newlength = prefix_size;

-   }

-}

-#endif

-

-/* Read and check the IDHR chunk */

-void /* PRIVATE */

-png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_byte buf[13];

-   png_uint_32 width, height;

-   int bit_depth, color_type, compression_type, filter_type;

-   int interlace_type;

-

-   png_debug(1, "in png_handle_IHDR");

-

-   if (png_ptr->mode & PNG_HAVE_IHDR)

-      png_error(png_ptr, "Out of place IHDR");

-

-   /* Check the length */

-   if (length != 13)

-      png_error(png_ptr, "Invalid IHDR chunk");

-

-   png_ptr->mode |= PNG_HAVE_IHDR;

-

-   png_crc_read(png_ptr, buf, 13);

-   png_crc_finish(png_ptr, 0);

-

-   width = png_get_uint_31(png_ptr, buf);

-   height = png_get_uint_31(png_ptr, buf + 4);

-   bit_depth = buf[8];

-   color_type = buf[9];

-   compression_type = buf[10];

-   filter_type = buf[11];

-   interlace_type = buf[12];

-

-   /* Set internal variables */

-   png_ptr->width = width;

-   png_ptr->height = height;

-   png_ptr->bit_depth = (png_byte)bit_depth;

-   png_ptr->interlaced = (png_byte)interlace_type;

-   png_ptr->color_type = (png_byte)color_type;

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   png_ptr->filter_type = (png_byte)filter_type;

-#endif

-   png_ptr->compression_type = (png_byte)compression_type;

-

-   /* Find number of channels */

-   switch (png_ptr->color_type)

-   {

-      case PNG_COLOR_TYPE_GRAY:

-      case PNG_COLOR_TYPE_PALETTE:

-         png_ptr->channels = 1;

-         break;

-

-      case PNG_COLOR_TYPE_RGB:

-         png_ptr->channels = 3;

-         break;

-

-      case PNG_COLOR_TYPE_GRAY_ALPHA:

-         png_ptr->channels = 2;

-         break;

-

-      case PNG_COLOR_TYPE_RGB_ALPHA:

-         png_ptr->channels = 4;

-         break;

-   }

-

-   /* Set up other useful info */

-   png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *

-   png_ptr->channels);

-   png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);

-   png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);

-   png_debug1(3, "channels = %d", png_ptr->channels);

-   png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);

-   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,

-      color_type, interlace_type, compression_type, filter_type);

-}

-

-/* Read and check the palette */

-void /* PRIVATE */

-png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_color palette[PNG_MAX_PALETTE_LENGTH];

-   int num, i;

-#ifdef PNG_POINTER_INDEXING_SUPPORTED

-   png_colorp pal_ptr;

-#endif

-

-   png_debug(1, "in png_handle_PLTE");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before PLTE");

-

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid PLTE after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      png_error(png_ptr, "Duplicate PLTE chunk");

-

-   png_ptr->mode |= PNG_HAVE_PLTE;

-

-   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))

-   {

-      png_warning(png_ptr,

-        "Ignoring PLTE chunk in grayscale PNG");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-#ifndef PNG_READ_OPT_PLTE_SUPPORTED

-   if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

-   {

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-#endif

-

-   if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)

-   {

-      if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

-      {

-         png_warning(png_ptr, "Invalid palette chunk");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-

-      else

-      {

-         png_error(png_ptr, "Invalid palette chunk");

-      }

-   }

-

-   num = (int)length / 3;

-

-#ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)

-   {

-      png_byte buf[3];

-

-      png_crc_read(png_ptr, buf, 3);

-      pal_ptr->red = buf[0];

-      pal_ptr->green = buf[1];

-      pal_ptr->blue = buf[2];

-   }

-#else

-   for (i = 0; i < num; i++)

-   {

-      png_byte buf[3];

-

-      png_crc_read(png_ptr, buf, 3);

-      /* Don't depend upon png_color being any order */

-      palette[i].red = buf[0];

-      palette[i].green = buf[1];

-      palette[i].blue = buf[2];

-   }

-#endif

-

-   /* If we actually NEED the PLTE chunk (ie for a paletted image), we do

-    * whatever the normal CRC configuration tells us.  However, if we

-    * have an RGB image, the PLTE can be considered ancillary, so

-    * we will act as though it is.

-    */

-#ifndef PNG_READ_OPT_PLTE_SUPPORTED

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-#endif

-   {

-      png_crc_finish(png_ptr, 0);

-   }

-#ifndef PNG_READ_OPT_PLTE_SUPPORTED

-   else if (png_crc_error(png_ptr))  /* Only if we have a CRC error */

-   {

-      /* If we don't want to use the data from an ancillary chunk,

-         we have two options: an error abort, or a warning and we

-         ignore the data in this chunk (which should be OK, since

-         it's considered ancillary for a RGB or RGBA image). */

-      if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))

-      {

-         if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)

-         {

-            png_chunk_error(png_ptr, "CRC error");

-         }

-         else

-         {

-            png_chunk_warning(png_ptr, "CRC error");

-            return;

-         }

-      }

-      /* Otherwise, we (optionally) emit a warning and use the chunk. */

-      else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))

-      {

-         png_chunk_warning(png_ptr, "CRC error");

-      }

-   }

-#endif

-

-   png_set_PLTE(png_ptr, info_ptr, palette, num);

-

-#ifdef PNG_READ_tRNS_SUPPORTED

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

-      {

-         if (png_ptr->num_trans > (png_uint_16)num)

-         {

-            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");

-            png_ptr->num_trans = (png_uint_16)num;

-         }

-         if (info_ptr->num_trans > (png_uint_16)num)

-         {

-            png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");

-            info_ptr->num_trans = (png_uint_16)num;

-         }

-      }

-   }

-#endif

-

-}

-

-void /* PRIVATE */

-png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_debug(1, "in png_handle_IEND");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))

-   {

-      png_error(png_ptr, "No image in file");

-   }

-

-   png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);

-

-   if (length != 0)

-   {

-      png_warning(png_ptr, "Incorrect IEND chunk length");

-   }

-   png_crc_finish(png_ptr, length);

-

-   info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */

-}

-

-#ifdef PNG_READ_gAMA_SUPPORTED

-void /* PRIVATE */

-png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_fixed_point igamma;

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   float file_gamma;

-#endif

-   png_byte buf[4];

-

-   png_debug(1, "in png_handle_gAMA");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before gAMA");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid gAMA after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place gAMA chunk");

-

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

-#ifdef PNG_READ_sRGB_SUPPORTED

-      && !(info_ptr->valid & PNG_INFO_sRGB)

-#endif

-      )

-   {

-      png_warning(png_ptr, "Duplicate gAMA chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 4)

-   {

-      png_warning(png_ptr, "Incorrect gAMA chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 4);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   igamma = (png_fixed_point)png_get_uint_32(buf);

-   /* Check for zero gamma */

-   if (igamma == 0)

-      {

-         png_warning(png_ptr,

-           "Ignoring gAMA chunk with gamma=0");

-         return;

-      }

-

-#ifdef PNG_READ_sRGB_SUPPORTED

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))

-      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))

-      {

-         png_warning(png_ptr,

-           "Ignoring incorrect gAMA value when sRGB is also present");

-#ifdef PNG_CONSOLE_IO_SUPPORTED

-         fprintf(stderr, "gamma = (%d/100000)", (int)igamma);

-#endif

-         return;

-      }

-#endif /* PNG_READ_sRGB_SUPPORTED */

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   file_gamma = (float)igamma / (float)100000.0;

-#  ifdef PNG_READ_GAMMA_SUPPORTED

-     png_ptr->gamma = file_gamma;

-#  endif

-     png_set_gAMA(png_ptr, info_ptr, file_gamma);

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   png_set_gAMA_fixed(png_ptr, info_ptr, igamma);

-#endif

-}

-#endif

-

-#ifdef PNG_READ_sBIT_SUPPORTED

-void /* PRIVATE */

-png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_size_t truelen;

-   png_byte buf[4];

-

-   png_debug(1, "in png_handle_sBIT");

-

-   buf[0] = buf[1] = buf[2] = buf[3] = 0;

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sBIT");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sBIT after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-   {

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place sBIT chunk");

-   }

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))

-   {

-      png_warning(png_ptr, "Duplicate sBIT chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      truelen = 3;

-   else

-      truelen = (png_size_t)png_ptr->channels;

-

-   if (length != truelen || length > 4)

-   {

-      png_warning(png_ptr, "Incorrect sBIT chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, truelen);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

-   {

-      png_ptr->sig_bit.red = buf[0];

-      png_ptr->sig_bit.green = buf[1];

-      png_ptr->sig_bit.blue = buf[2];

-      png_ptr->sig_bit.alpha = buf[3];

-   }

-   else

-   {

-      png_ptr->sig_bit.gray = buf[0];

-      png_ptr->sig_bit.red = buf[0];

-      png_ptr->sig_bit.green = buf[0];

-      png_ptr->sig_bit.blue = buf[0];

-      png_ptr->sig_bit.alpha = buf[1];

-   }

-   png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));

-}

-#endif

-

-#ifdef PNG_READ_cHRM_SUPPORTED

-void /* PRIVATE */

-png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_byte buf[32];

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

-#endif

-   png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

-      int_y_green, int_x_blue, int_y_blue;

-

-   png_uint_32 uint_x, uint_y;

-

-   png_debug(1, "in png_handle_cHRM");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before cHRM");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid cHRM after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Missing PLTE before cHRM");

-

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)

-#ifdef PNG_READ_sRGB_SUPPORTED

-      && !(info_ptr->valid & PNG_INFO_sRGB)

-#endif

-      )

-   {

-      png_warning(png_ptr, "Duplicate cHRM chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 32)

-   {

-      png_warning(png_ptr, "Incorrect cHRM chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 32);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   uint_x = png_get_uint_32(buf);

-   uint_y = png_get_uint_32(buf + 4);

-   int_x_white = (png_fixed_point)uint_x;

-   int_y_white = (png_fixed_point)uint_y;

-

-   uint_x = png_get_uint_32(buf + 8);

-   uint_y = png_get_uint_32(buf + 12);

-   int_x_red = (png_fixed_point)uint_x;

-   int_y_red = (png_fixed_point)uint_y;

-

-   uint_x = png_get_uint_32(buf + 16);

-   uint_y = png_get_uint_32(buf + 20);

-   int_x_green = (png_fixed_point)uint_x;

-   int_y_green = (png_fixed_point)uint_y;

-

-   uint_x = png_get_uint_32(buf + 24);

-   uint_y = png_get_uint_32(buf + 28);

-   int_x_blue = (png_fixed_point)uint_x;

-   int_y_blue = (png_fixed_point)uint_y;

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   white_x = (float)int_x_white / (float)100000.0;

-   white_y = (float)int_y_white / (float)100000.0;

-   red_x   = (float)int_x_red   / (float)100000.0;

-   red_y   = (float)int_y_red   / (float)100000.0;

-   green_x = (float)int_x_green / (float)100000.0;

-   green_y = (float)int_y_green / (float)100000.0;

-   blue_x  = (float)int_x_blue  / (float)100000.0;

-   blue_y  = (float)int_y_blue  / (float)100000.0;

-#endif

-

-#ifdef PNG_READ_sRGB_SUPPORTED

-   if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB))

-      {

-      if (PNG_OUT_OF_RANGE(int_x_white, 31270,  1000) ||

-          PNG_OUT_OF_RANGE(int_y_white, 32900,  1000) ||

-          PNG_OUT_OF_RANGE(int_x_red,   64000L, 1000) ||

-          PNG_OUT_OF_RANGE(int_y_red,   33000,  1000) ||

-          PNG_OUT_OF_RANGE(int_x_green, 30000,  1000) ||

-          PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) ||

-          PNG_OUT_OF_RANGE(int_x_blue,  15000,  1000) ||

-          PNG_OUT_OF_RANGE(int_y_blue,   6000,  1000))

-         {

-            png_warning(png_ptr,

-              "Ignoring incorrect cHRM value when sRGB is also present");

-#ifdef PNG_CONSOLE_IO_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-            fprintf(stderr, "wx=%f, wy=%f, rx=%f, ry=%f\n",

-               white_x, white_y, red_x, red_y);

-            fprintf(stderr, "gx=%f, gy=%f, bx=%f, by=%f\n",

-               green_x, green_y, blue_x, blue_y);

-#else

-            fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n",

-               int_x_white, int_y_white, int_x_red, int_y_red);

-            fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n",

-               int_x_green, int_y_green, int_x_blue, int_y_blue);

-#endif

-#endif /* PNG_CONSOLE_IO_SUPPORTED */

-         }

-         return;

-      }

-#endif /* PNG_READ_sRGB_SUPPORTED */

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   png_set_cHRM(png_ptr, info_ptr,

-      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   png_set_cHRM_fixed(png_ptr, info_ptr,

-      int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

-      int_y_green, int_x_blue, int_y_blue);

-#endif

-}

-#endif

-

-#ifdef PNG_READ_sRGB_SUPPORTED

-void /* PRIVATE */

-png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   int intent;

-   png_byte buf[1];

-

-   png_debug(1, "in png_handle_sRGB");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sRGB");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sRGB after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place sRGB chunk");

-

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))

-   {

-      png_warning(png_ptr, "Duplicate sRGB chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 1)

-   {

-      png_warning(png_ptr, "Incorrect sRGB chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 1);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   intent = buf[0];

-   /* Check for bad intent */

-   if (intent >= PNG_sRGB_INTENT_LAST)

-   {

-      png_warning(png_ptr, "Unknown sRGB intent");

-      return;

-   }

-

-#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA))

-   {

-   png_fixed_point igamma;

-#ifdef PNG_FIXED_POINT_SUPPORTED

-      igamma=info_ptr->int_gamma;

-#else

-#  ifdef PNG_FLOATING_POINT_SUPPORTED

-      igamma=(png_fixed_point)(info_ptr->gamma * 100000.);

-#  endif

-#endif

-      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))

-      {

-         png_warning(png_ptr,

-           "Ignoring incorrect gAMA value when sRGB is also present");

-#ifdef PNG_CONSOLE_IO_SUPPORTED

-#  ifdef PNG_FIXED_POINT_SUPPORTED

-         fprintf(stderr, "incorrect gamma=(%d/100000)\n",

-            (int)png_ptr->int_gamma);

-#  else

-#    ifdef PNG_FLOATING_POINT_SUPPORTED

-         fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);

-#    endif

-#  endif

-#endif

-      }

-   }

-#endif /* PNG_READ_gAMA_SUPPORTED */

-

-#ifdef PNG_READ_cHRM_SUPPORTED

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

-      if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_x_red,   64000L, 1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_red,   33000,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_x_blue,  15000,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_blue,   6000,  1000))

-         {

-            png_warning(png_ptr,

-              "Ignoring incorrect cHRM value when sRGB is also present");

-         }

-#endif /* PNG_FIXED_POINT_SUPPORTED */

-#endif /* PNG_READ_cHRM_SUPPORTED */

-

-   png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);

-}

-#endif /* PNG_READ_sRGB_SUPPORTED */

-

-#ifdef PNG_READ_iCCP_SUPPORTED

-void /* PRIVATE */

-png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-/* Note: this does not properly handle chunks that are > 64K under DOS */

-{

-   png_byte compression_type;

-   png_bytep pC;

-   png_charp profile;

-   png_uint_32 skip = 0;

-   png_uint_32 profile_size, profile_length;

-   png_size_t slength, prefix_length, data_length;

-

-   png_debug(1, "in png_handle_iCCP");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before iCCP");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid iCCP after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place iCCP chunk");

-

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))

-   {

-      png_warning(png_ptr, "Duplicate iCCP chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-#ifdef PNG_MAX_MALLOC_64K

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "iCCP chunk too large to fit in memory");

-      skip = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, skip))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (profile = png_ptr->chunkdata; *profile; profile++)

-      /* Empty loop to find end of name */ ;

-

-   ++profile;

-

-   /* There should be at least one zero (the compression type byte)

-    * following the separator, and we should be on it

-    */

-   if ( profile >= png_ptr->chunkdata + slength - 1)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "Malformed iCCP chunk");

-      return;

-   }

-

-   /* Compression_type should always be zero */

-   compression_type = *profile++;

-   if (compression_type)

-   {

-      png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");

-      compression_type = 0x00;  /* Reset it to zero (libpng-1.0.6 through 1.0.8

-                                 wrote nonzero) */

-   }

-

-   prefix_length = profile - png_ptr->chunkdata;

-   png_decompress_chunk(png_ptr, compression_type,

-     slength, prefix_length, &data_length);

-

-   profile_length = data_length - prefix_length;

-

-   if ( prefix_length > data_length || profile_length < 4)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "Profile size field missing from iCCP chunk");

-      return;

-   }

-

-   /* Check the profile_size recorded in the first 32 bits of the ICC profile */

-   pC = (png_bytep)(png_ptr->chunkdata + prefix_length);

-   profile_size = ((*(pC    ))<<24) |

-                  ((*(pC + 1))<<16) |

-                  ((*(pC + 2))<< 8) |

-                  ((*(pC + 3))    );

-

-   if (profile_size < profile_length)

-      profile_length = profile_size;

-

-   if (profile_size > profile_length)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "Ignoring truncated iCCP profile.");

-      return;

-   }

-

-   png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,

-     compression_type, png_ptr->chunkdata + prefix_length, profile_length);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-}

-#endif /* PNG_READ_iCCP_SUPPORTED */

-

-#ifdef PNG_READ_sPLT_SUPPORTED

-void /* PRIVATE */

-png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-/* Note: this does not properly handle chunks that are > 64K under DOS */

-{

-   png_bytep entry_start;

-   png_sPLT_t new_palette;

-#ifdef PNG_POINTER_INDEXING_SUPPORTED

-   png_sPLT_entryp pp;

-#endif

-   int data_length, entry_size, i;

-   png_uint_32 skip = 0;

-   png_size_t slength;

-

-   png_debug(1, "in png_handle_sPLT");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sPLT");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sPLT after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-#ifdef PNG_MAX_MALLOC_64K

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "sPLT chunk too large to fit in memory");

-      skip = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, skip))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++)

-      /* Empty loop to find end of name */ ;

-   ++entry_start;

-

-   /* A sample depth should follow the separator, and we should be on it  */

-   if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "malformed sPLT chunk");

-      return;

-   }

-

-   new_palette.depth = *entry_start++;

-   entry_size = (new_palette.depth == 8 ? 6 : 10);

-   data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));

-

-   /* Integrity-check the data length */

-   if (data_length % entry_size)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "sPLT chunk has bad length");

-      return;

-   }

-

-   new_palette.nentries = (png_int_32) ( data_length / entry_size);

-   if ((png_uint_32) new_palette.nentries >

-       (png_uint_32) (PNG_SIZE_MAX / png_sizeof(png_sPLT_entry)))

-   {

-       png_warning(png_ptr, "sPLT chunk too long");

-       return;

-   }

-   new_palette.entries = (png_sPLT_entryp)png_malloc_warn(

-       png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));

-   if (new_palette.entries == NULL)

-   {

-       png_warning(png_ptr, "sPLT chunk requires too much memory");

-       return;

-   }

-

-#ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (i = 0; i < new_palette.nentries; i++)

-   {

-      pp = new_palette.entries + i;

-

-      if (new_palette.depth == 8)

-      {

-          pp->red = *entry_start++;

-          pp->green = *entry_start++;

-          pp->blue = *entry_start++;

-          pp->alpha = *entry_start++;

-      }

-      else

-      {

-          pp->red   = png_get_uint_16(entry_start); entry_start += 2;

-          pp->green = png_get_uint_16(entry_start); entry_start += 2;

-          pp->blue  = png_get_uint_16(entry_start); entry_start += 2;

-          pp->alpha = png_get_uint_16(entry_start); entry_start += 2;

-      }

-      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;

-   }

-#else

-   pp = new_palette.entries;

-   for (i = 0; i < new_palette.nentries; i++)

-   {

-

-      if (new_palette.depth == 8)

-      {

-          pp[i].red   = *entry_start++;

-          pp[i].green = *entry_start++;

-          pp[i].blue  = *entry_start++;

-          pp[i].alpha = *entry_start++;

-      }

-      else

-      {

-          pp[i].red   = png_get_uint_16(entry_start); entry_start += 2;

-          pp[i].green = png_get_uint_16(entry_start); entry_start += 2;

-          pp[i].blue  = png_get_uint_16(entry_start); entry_start += 2;

-          pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;

-      }

-      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;

-   }

-#endif

-

-   /* Discard all chunk data except the name and stash that */

-   new_palette.name = png_ptr->chunkdata;

-

-   png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   png_free(png_ptr, new_palette.entries);

-}

-#endif /* PNG_READ_sPLT_SUPPORTED */

-

-#ifdef PNG_READ_tRNS_SUPPORTED

-void /* PRIVATE */

-png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_byte readbuf[PNG_MAX_PALETTE_LENGTH];

-

-   png_debug(1, "in png_handle_tRNS");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before tRNS");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid tRNS after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

-   {

-      png_warning(png_ptr, "Duplicate tRNS chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      png_byte buf[2];

-

-      if (length != 2)

-      {

-         png_warning(png_ptr, "Incorrect tRNS chunk length");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-

-      png_crc_read(png_ptr, buf, 2);

-      png_ptr->num_trans = 1;

-      png_ptr->trans_values.gray = png_get_uint_16(buf);

-   }

-   else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-   {

-      png_byte buf[6];

-

-      if (length != 6)

-      {

-         png_warning(png_ptr, "Incorrect tRNS chunk length");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      png_crc_read(png_ptr, buf, (png_size_t)length);

-      png_ptr->num_trans = 1;

-      png_ptr->trans_values.red = png_get_uint_16(buf);

-      png_ptr->trans_values.green = png_get_uint_16(buf + 2);

-      png_ptr->trans_values.blue = png_get_uint_16(buf + 4);

-   }

-   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (!(png_ptr->mode & PNG_HAVE_PLTE))

-      {

-         /* Should be an error, but we can cope with it. */

-         png_warning(png_ptr, "Missing PLTE before tRNS");

-      }

-      if (length > (png_uint_32)png_ptr->num_palette ||

-          length > PNG_MAX_PALETTE_LENGTH)

-      {

-         png_warning(png_ptr, "Incorrect tRNS chunk length");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      if (length == 0)

-      {

-         png_warning(png_ptr, "Zero length tRNS chunk");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      png_crc_read(png_ptr, readbuf, (png_size_t)length);

-      png_ptr->num_trans = (png_uint_16)length;

-   }

-   else

-   {

-      png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_ptr->num_trans = 0;

-      return;

-   }

-

-   png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,

-      &(png_ptr->trans_values));

-}

-#endif

-

-#ifdef PNG_READ_bKGD_SUPPORTED

-void /* PRIVATE */

-png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_size_t truelen;

-   png_byte buf[6];

-

-   png_debug(1, "in png_handle_bKGD");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before bKGD");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid bKGD after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

-            !(png_ptr->mode & PNG_HAVE_PLTE))

-   {

-      png_warning(png_ptr, "Missing PLTE before bKGD");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))

-   {

-      png_warning(png_ptr, "Duplicate bKGD chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      truelen = 1;

-   else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

-      truelen = 6;

-   else

-      truelen = 2;

-

-   if (length != truelen)

-   {

-      png_warning(png_ptr, "Incorrect bKGD chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, truelen);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   /* We convert the index value into RGB components so that we can allow

-    * arbitrary RGB values for background when we have transparency, and

-    * so it is easy to determine the RGB values of the background color

-    * from the info_ptr struct. */

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      png_ptr->background.index = buf[0];

-      if (info_ptr && info_ptr->num_palette)

-      {

-          if (buf[0] >= info_ptr->num_palette)

-          {

-             png_warning(png_ptr, "Incorrect bKGD chunk index value");

-             return;

-          }

-          png_ptr->background.red =

-             (png_uint_16)png_ptr->palette[buf[0]].red;

-          png_ptr->background.green =

-             (png_uint_16)png_ptr->palette[buf[0]].green;

-          png_ptr->background.blue =

-             (png_uint_16)png_ptr->palette[buf[0]].blue;

-      }

-   }

-   else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */

-   {

-      png_ptr->background.red =

-      png_ptr->background.green =

-      png_ptr->background.blue =

-      png_ptr->background.gray = png_get_uint_16(buf);

-   }

-   else

-   {

-      png_ptr->background.red = png_get_uint_16(buf);

-      png_ptr->background.green = png_get_uint_16(buf + 2);

-      png_ptr->background.blue = png_get_uint_16(buf + 4);

-   }

-

-   png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));

-}

-#endif

-

-#ifdef PNG_READ_hIST_SUPPORTED

-void /* PRIVATE */

-png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   unsigned int num, i;

-   png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];

-

-   png_debug(1, "in png_handle_hIST");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before hIST");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid hIST after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (!(png_ptr->mode & PNG_HAVE_PLTE))

-   {

-      png_warning(png_ptr, "Missing PLTE before hIST");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))

-   {

-      png_warning(png_ptr, "Duplicate hIST chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   num = length / 2 ;

-   if (num != (unsigned int) png_ptr->num_palette || num >

-      (unsigned int) PNG_MAX_PALETTE_LENGTH)

-   {

-      png_warning(png_ptr, "Incorrect hIST chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   for (i = 0; i < num; i++)

-   {

-      png_byte buf[2];

-

-      png_crc_read(png_ptr, buf, 2);

-      readbuf[i] = png_get_uint_16(buf);

-   }

-

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   png_set_hIST(png_ptr, info_ptr, readbuf);

-}

-#endif

-

-#ifdef PNG_READ_pHYs_SUPPORTED

-void /* PRIVATE */

-png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_byte buf[9];

-   png_uint_32 res_x, res_y;

-   int unit_type;

-

-   png_debug(1, "in png_handle_pHYs");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before pHYs");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid pHYs after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))

-   {

-      png_warning(png_ptr, "Duplicate pHYs chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 9)

-   {

-      png_warning(png_ptr, "Incorrect pHYs chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 9);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   res_x = png_get_uint_32(buf);

-   res_y = png_get_uint_32(buf + 4);

-   unit_type = buf[8];

-   png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);

-}

-#endif

-

-#ifdef PNG_READ_oFFs_SUPPORTED

-void /* PRIVATE */

-png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_byte buf[9];

-   png_int_32 offset_x, offset_y;

-   int unit_type;

-

-   png_debug(1, "in png_handle_oFFs");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before oFFs");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid oFFs after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))

-   {

-      png_warning(png_ptr, "Duplicate oFFs chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 9)

-   {

-      png_warning(png_ptr, "Incorrect oFFs chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 9);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   offset_x = png_get_int_32(buf);

-   offset_y = png_get_int_32(buf + 4);

-   unit_type = buf[8];

-   png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);

-}

-#endif

-

-#ifdef PNG_READ_pCAL_SUPPORTED

-/* Read the pCAL chunk (described in the PNG Extensions document) */

-void /* PRIVATE */

-png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_int_32 X0, X1;

-   png_byte type, nparams;

-   png_charp buf, units, endptr;

-   png_charpp params;

-   png_size_t slength;

-   int i;

-

-   png_debug(1, "in png_handle_pCAL");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before pCAL");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid pCAL after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))

-   {

-      png_warning(png_ptr, "Duplicate pCAL chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)",

-      length + 1);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-     {

-       png_warning(png_ptr, "No memory for pCAL purpose.");

-       return;

-     }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */

-

-   png_debug(3, "Finding end of pCAL purpose string");

-   for (buf = png_ptr->chunkdata; *buf; buf++)

-      /* Empty loop */ ;

-

-   endptr = png_ptr->chunkdata + slength;

-

-   /* We need to have at least 12 bytes after the purpose string

-      in order to get the parameter information. */

-   if (endptr <= buf + 12)

-   {

-      png_warning(png_ptr, "Invalid pCAL data");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_debug(3, "Reading pCAL X0, X1, type, nparams, and units");

-   X0 = png_get_int_32((png_bytep)buf+1);

-   X1 = png_get_int_32((png_bytep)buf+5);

-   type = buf[9];

-   nparams = buf[10];

-   units = buf + 11;

-

-   png_debug(3, "Checking pCAL equation type and number of parameters");

-   /* Check that we have the right number of parameters for known

-      equation types. */

-   if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||

-       (type == PNG_EQUATION_BASE_E && nparams != 3) ||

-       (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||

-       (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))

-   {

-      png_warning(png_ptr, "Invalid pCAL parameters for equation type");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-   else if (type >= PNG_EQUATION_LAST)

-   {

-      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

-   }

-

-   for (buf = units; *buf; buf++)

-      /* Empty loop to move past the units string. */ ;

-

-   png_debug(3, "Allocating pCAL parameters array");

-   params = (png_charpp)png_malloc_warn(png_ptr,

-      (png_uint_32)(nparams * png_sizeof(png_charp))) ;

-   if (params == NULL)

-     {

-       png_free(png_ptr, png_ptr->chunkdata);

-       png_ptr->chunkdata = NULL;

-       png_warning(png_ptr, "No memory for pCAL params.");

-       return;

-     }

-

-   /* Get pointers to the start of each parameter string. */

-   for (i = 0; i < (int)nparams; i++)

-   {

-      buf++; /* Skip the null string terminator from previous parameter. */

-

-      png_debug1(3, "Reading pCAL parameter %d", i);

-      for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++)

-         /* Empty loop to move past each parameter string */ ;

-

-      /* Make sure we haven't run out of data yet */

-      if (buf > endptr)

-      {

-         png_warning(png_ptr, "Invalid pCAL data");

-         png_free(png_ptr, png_ptr->chunkdata);

-         png_ptr->chunkdata = NULL;

-         png_free(png_ptr, params);

-         return;

-      }

-   }

-

-   png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,

-      units, params);

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   png_free(png_ptr, params);

-}

-#endif

-

-#ifdef PNG_READ_sCAL_SUPPORTED

-/* Read the sCAL chunk */

-void /* PRIVATE */

-png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_charp ep;

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   double width, height;

-   png_charp vp;

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   png_charp swidth, sheight;

-#endif

-#endif

-   png_size_t slength;

-

-   png_debug(1, "in png_handle_sCAL");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sCAL");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sCAL after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))

-   {

-      png_warning(png_ptr, "Duplicate sCAL chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)",

-      length + 1);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while processing sCAL chunk");

-      return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */

-

-   ep = png_ptr->chunkdata + 1;        /* Skip unit byte */

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   width = png_strtod(png_ptr, ep, &vp);

-   if (*vp)

-   {

-      png_warning(png_ptr, "malformed width string in sCAL chunk");

-      return;

-   }

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

-   if (swidth == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while processing sCAL chunk width");

-      return;

-   }

-   png_memcpy(swidth, ep, (png_size_t)png_strlen(ep));

-#endif

-#endif

-

-   for (ep = png_ptr->chunkdata; *ep; ep++)

-      /* Empty loop */ ;

-   ep++;

-

-   if (png_ptr->chunkdata + slength < ep)

-   {

-      png_warning(png_ptr, "Truncated sCAL chunk");

-#if defined(PNG_FIXED_POINT_SUPPORTED) && \

-    !defined(PNG_FLOATING_POINT_SUPPORTED)

-      png_free(png_ptr, swidth);

-#endif

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   height = png_strtod(png_ptr, ep, &vp);

-   if (*vp)

-   {

-      png_warning(png_ptr, "malformed height string in sCAL chunk");

-      return;

-   }

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

-   if (sheight == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while processing sCAL chunk height");

-      return;

-   }

-   png_memcpy(sheight, ep, (png_size_t)png_strlen(ep));

-#endif

-#endif

-

-   if (png_ptr->chunkdata + slength < ep

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-      || width <= 0. || height <= 0.

-#endif

-      )

-   {

-      png_warning(png_ptr, "Invalid sCAL data");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)

-      png_free(png_ptr, swidth);

-      png_free(png_ptr, sheight);

-#endif

-      return;

-   }

-

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);

-#endif

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)

-   png_free(png_ptr, swidth);

-   png_free(png_ptr, sheight);

-#endif

-}

-#endif

-

-#ifdef PNG_READ_tIME_SUPPORTED

-void /* PRIVATE */

-png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_byte buf[7];

-   png_time mod_time;

-

-   png_debug(1, "in png_handle_tIME");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Out of place tIME chunk");

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))

-   {

-      png_warning(png_ptr, "Duplicate tIME chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

-

-   if (length != 7)

-   {

-      png_warning(png_ptr, "Incorrect tIME chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 7);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   mod_time.second = buf[6];

-   mod_time.minute = buf[5];

-   mod_time.hour = buf[4];

-   mod_time.day = buf[3];

-   mod_time.month = buf[2];

-   mod_time.year = png_get_uint_16(buf);

-

-   png_set_tIME(png_ptr, info_ptr, &mod_time);

-}

-#endif

-

-#ifdef PNG_READ_tEXt_SUPPORTED

-/* Note: this does not properly handle chunks that are > 64K under DOS */

-void /* PRIVATE */

-png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_textp text_ptr;

-   png_charp key;

-   png_charp text;

-   png_uint_32 skip = 0;

-   png_size_t slength;

-   int ret;

-

-   png_debug(1, "in png_handle_tEXt");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before tEXt");

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

-

-#ifdef PNG_MAX_MALLOC_64K

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "tEXt chunk too large to fit in memory");

-      skip = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-     png_warning(png_ptr, "No memory to process text chunk.");

-     return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, skip))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   key = png_ptr->chunkdata;

-

-   key[slength] = 0x00;

-

-   for (text = key; *text; text++)

-      /* Empty loop to find end of key */ ;

-

-   if (text != key + slength)

-      text++;

-

-   text_ptr = (png_textp)png_malloc_warn(png_ptr,

-      (png_uint_32)png_sizeof(png_text));

-   if (text_ptr == NULL)

-   {

-     png_warning(png_ptr, "Not enough memory to process text chunk.");

-     png_free(png_ptr, png_ptr->chunkdata);

-     png_ptr->chunkdata = NULL;

-     return;

-   }

-   text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

-   text_ptr->key = key;

-#ifdef PNG_iTXt_SUPPORTED

-   text_ptr->lang = NULL;

-   text_ptr->lang_key = NULL;

-   text_ptr->itxt_length = 0;

-#endif

-   text_ptr->text = text;

-   text_ptr->text_length = png_strlen(text);

-

-   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   png_free(png_ptr, text_ptr);

-   if (ret)

-     png_warning(png_ptr, "Insufficient memory to process text chunk.");

-}

-#endif

-

-#ifdef PNG_READ_zTXt_SUPPORTED

-/* Note: this does not correctly handle chunks that are > 64K under DOS */

-void /* PRIVATE */

-png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_textp text_ptr;

-   png_charp text;

-   int comp_type;

-   int ret;

-   png_size_t slength, prefix_len, data_len;

-

-   png_debug(1, "in png_handle_zTXt");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before zTXt");

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

-

-#ifdef PNG_MAX_MALLOC_64K

-   /* We will no doubt have problems with chunks even half this size, but

-      there is no hard and fast rule to tell us where to stop. */

-   if (length > (png_uint_32)65535L)

-   {

-     png_warning(png_ptr, "zTXt chunk too large to fit in memory");

-     png_crc_finish(png_ptr, length);

-     return;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-     png_warning(png_ptr, "Out of memory processing zTXt chunk.");

-     return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (text = png_ptr->chunkdata; *text; text++)

-      /* Empty loop */ ;

-

-   /* zTXt must have some text after the chunkdataword */

-   if (text >= png_ptr->chunkdata + slength - 2)

-   {

-      png_warning(png_ptr, "Truncated zTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-   else

-   {

-       comp_type = *(++text);

-       if (comp_type != PNG_TEXT_COMPRESSION_zTXt)

-       {

-          png_warning(png_ptr, "Unknown compression type in zTXt chunk");

-          comp_type = PNG_TEXT_COMPRESSION_zTXt;

-       }

-       text++;        /* Skip the compression_method byte */

-   }

-   prefix_len = text - png_ptr->chunkdata;

-

-   png_decompress_chunk(png_ptr, comp_type,

-     (png_size_t)length, prefix_len, &data_len);

-

-   text_ptr = (png_textp)png_malloc_warn(png_ptr,

-      (png_uint_32)png_sizeof(png_text));

-   if (text_ptr == NULL)

-   {

-     png_warning(png_ptr, "Not enough memory to process zTXt chunk.");

-     png_free(png_ptr, png_ptr->chunkdata);

-     png_ptr->chunkdata = NULL;

-     return;

-   }

-   text_ptr->compression = comp_type;

-   text_ptr->key = png_ptr->chunkdata;

-#ifdef PNG_iTXt_SUPPORTED

-   text_ptr->lang = NULL;

-   text_ptr->lang_key = NULL;

-   text_ptr->itxt_length = 0;

-#endif

-   text_ptr->text = png_ptr->chunkdata + prefix_len;

-   text_ptr->text_length = data_len;

-

-   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

-

-   png_free(png_ptr, text_ptr);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   if (ret)

-     png_error(png_ptr, "Insufficient memory to store zTXt chunk.");

-}

-#endif

-

-#ifdef PNG_READ_iTXt_SUPPORTED

-/* Note: this does not correctly handle chunks that are > 64K under DOS */

-void /* PRIVATE */

-png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_textp text_ptr;

-   png_charp key, lang, text, lang_key;

-   int comp_flag;

-   int comp_type = 0;

-   int ret;

-   png_size_t slength, prefix_len, data_len;

-

-   png_debug(1, "in png_handle_iTXt");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before iTXt");

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

-

-#ifdef PNG_MAX_MALLOC_64K

-   /* We will no doubt have problems with chunks even half this size, but

-      there is no hard and fast rule to tell us where to stop. */

-   if (length > (png_uint_32)65535L)

-   {

-     png_warning(png_ptr, "iTXt chunk too large to fit in memory");

-     png_crc_finish(png_ptr, length);

-     return;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-     png_warning(png_ptr, "No memory to process iTXt chunk.");

-     return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (lang = png_ptr->chunkdata; *lang; lang++)

-      /* Empty loop */ ;

-   lang++;        /* Skip NUL separator */

-

-   /* iTXt must have a language tag (possibly empty), two compression bytes,

-    * translated keyword (possibly empty), and possibly some text after the

-    * keyword

-    */

-

-   if (lang >= png_ptr->chunkdata + slength - 3)

-   {

-      png_warning(png_ptr, "Truncated iTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-   else

-   {

-       comp_flag = *lang++;

-       comp_type = *lang++;

-   }

-

-   for (lang_key = lang; *lang_key; lang_key++)

-      /* Empty loop */ ;

-   lang_key++;        /* Skip NUL separator */

-

-   if (lang_key >= png_ptr->chunkdata + slength)

-   {

-      png_warning(png_ptr, "Truncated iTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   for (text = lang_key; *text; text++)

-      /* Empty loop */ ;

-   text++;        /* Skip NUL separator */

-   if (text >= png_ptr->chunkdata + slength)

-   {

-      png_warning(png_ptr, "Malformed iTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   prefix_len = text - png_ptr->chunkdata;

-

-   key=png_ptr->chunkdata;

-   if (comp_flag)

-       png_decompress_chunk(png_ptr, comp_type,

-         (size_t)length, prefix_len, &data_len);

-   else

-       data_len = png_strlen(png_ptr->chunkdata + prefix_len);

-   text_ptr = (png_textp)png_malloc_warn(png_ptr,

-      (png_uint_32)png_sizeof(png_text));

-   if (text_ptr == NULL)

-   {

-     png_warning(png_ptr, "Not enough memory to process iTXt chunk.");

-     png_free(png_ptr, png_ptr->chunkdata);

-     png_ptr->chunkdata = NULL;

-     return;

-   }

-   text_ptr->compression = (int)comp_flag + 1;

-   text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);

-   text_ptr->lang = png_ptr->chunkdata + (lang - key);

-   text_ptr->itxt_length = data_len;

-   text_ptr->text_length = 0;

-   text_ptr->key = png_ptr->chunkdata;

-   text_ptr->text = png_ptr->chunkdata + prefix_len;

-

-   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

-

-   png_free(png_ptr, text_ptr);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   if (ret)

-     png_error(png_ptr, "Insufficient memory to store iTXt chunk.");

-}

-#endif

-

-/* This function is called when we haven't found a handler for a

-   chunk.  If there isn't a problem with the chunk itself (ie bad

-   chunk name, CRC, or a critical chunk), the chunk is silently ignored

-   -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which

-   case it will be saved away to be written out later. */

-void /* PRIVATE */

-png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

-{

-   png_uint_32 skip = 0;

-

-   png_debug(1, "in png_handle_unknown");

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-#ifdef PNG_USE_LOCAL_ARRAYS

-      PNG_CONST PNG_IDAT;

-#endif

-      if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))  /* Not an IDAT */

-         png_ptr->mode |= PNG_AFTER_IDAT;

-   }

-

-   if (!(png_ptr->chunk_name[0] & 0x20))

-   {

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-      if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

-           PNG_HANDLE_CHUNK_ALWAYS

-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-           && png_ptr->read_user_chunk_fn == NULL

-#endif

-        )

-#endif

-          png_chunk_error(png_ptr, "unknown critical chunk");

-   }

-

-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-   if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-       || (png_ptr->read_user_chunk_fn != NULL)

-#endif

-        )

-   {

-#ifdef PNG_MAX_MALLOC_64K

-       if (length > (png_uint_32)65535L)

-       {

-           png_warning(png_ptr, "unknown chunk too large to fit in memory");

-           skip = length - (png_uint_32)65535L;

-           length = (png_uint_32)65535L;

-       }

-#endif

-       png_memcpy((png_charp)png_ptr->unknown_chunk.name,

-                  (png_charp)png_ptr->chunk_name,

-                  png_sizeof(png_ptr->unknown_chunk.name));

-       png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1] = '\0';

-       png_ptr->unknown_chunk.size = (png_size_t)length;

-       if (length == 0)

-         png_ptr->unknown_chunk.data = NULL;

-       else

-       {

-         png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);

-         png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);

-       }

-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-       if (png_ptr->read_user_chunk_fn != NULL)

-       {

-          /* Callback to user unknown chunk handler */

-          int ret;

-          ret = (*(png_ptr->read_user_chunk_fn))

-            (png_ptr, &png_ptr->unknown_chunk);

-          if (ret < 0)

-             png_chunk_error(png_ptr, "error in user chunk");

-          if (ret == 0)

-          {

-             if (!(png_ptr->chunk_name[0] & 0x20))

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-                if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

-                     PNG_HANDLE_CHUNK_ALWAYS)

-#endif

-                   png_chunk_error(png_ptr, "unknown critical chunk");

-             png_set_unknown_chunks(png_ptr, info_ptr,

-               &png_ptr->unknown_chunk, 1);

-          }

-       }

-       else

-#endif

-       png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);

-       png_free(png_ptr, png_ptr->unknown_chunk.data);

-       png_ptr->unknown_chunk.data = NULL;

-   }

-   else

-#endif

-      skip = length;

-

-   png_crc_finish(png_ptr, skip);

-

-#ifndef PNG_READ_USER_CHUNKS_SUPPORTED

-   info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */

-#endif

-}

-

-/* This function is called to verify that a chunk name is valid.

-   This function can't have the "critical chunk check" incorporated

-   into it, since in the future we will need to be able to call user

-   functions to handle unknown critical chunks after we check that

-   the chunk name itself is valid. */

-

-#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))

-

-void /* PRIVATE */

-png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)

-{

-   png_debug(1, "in png_check_chunk_name");

-   if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||

-       isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))

-   {

-      png_chunk_error(png_ptr, "invalid chunk type");

-   }

-}

-

-/* Combines the row recently read in with the existing pixels in the

-   row.  This routine takes care of alpha and transparency if requested.

-   This routine also handles the two methods of progressive display

-   of interlaced images, depending on the mask value.

-   The mask value describes which pixels are to be combined with

-   the row.  The pattern always repeats every 8 pixels, so just 8

-   bits are needed.  A one indicates the pixel is to be combined,

-   a zero indicates the pixel is to be skipped.  This is in addition

-   to any alpha or transparency value associated with the pixel.  If

-   you want all pixels to be combined, pass 0xff (255) in mask.  */

-

-void /* PRIVATE */

-png_combine_row(png_structp png_ptr, png_bytep row, int mask)

-{

-   png_debug(1, "in png_combine_row");

-   if (mask == 0xff)

-   {

-      png_memcpy(row, png_ptr->row_buf + 1,

-         PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));

-   }

-   else

-   {

-      switch (png_ptr->row_info.pixel_depth)

-      {

-         case 1:

-         {

-            png_bytep sp = png_ptr->row_buf + 1;

-            png_bytep dp = row;

-            int s_inc, s_start, s_end;

-            int m = 0x80;

-            int shift;

-            png_uint_32 i;

-            png_uint_32 row_width = png_ptr->width;

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (png_ptr->transformations & PNG_PACKSWAP)

-            {

-                s_start = 0;

-                s_end = 7;

-                s_inc = 1;

-            }

-            else

-#endif

-            {

-                s_start = 7;

-                s_end = 0;

-                s_inc = -1;

-            }

-

-            shift = s_start;

-

-            for (i = 0; i < row_width; i++)

-            {

-               if (m & mask)

-               {

-                  int value;

-

-                  value = (*sp >> shift) & 0x01;

-                  *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

-                  *dp |= (png_byte)(value << shift);

-               }

-

-               if (shift == s_end)

-               {

-                  shift = s_start;

-                  sp++;

-                  dp++;

-               }

-               else

-                  shift += s_inc;

-

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

-            }

-            break;

-         }

-         case 2:

-         {

-            png_bytep sp = png_ptr->row_buf + 1;

-            png_bytep dp = row;

-            int s_start, s_end, s_inc;

-            int m = 0x80;

-            int shift;

-            png_uint_32 i;

-            png_uint_32 row_width = png_ptr->width;

-            int value;

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (png_ptr->transformations & PNG_PACKSWAP)

-            {

-               s_start = 0;

-               s_end = 6;

-               s_inc = 2;

-            }

-            else

-#endif

-            {

-               s_start = 6;

-               s_end = 0;

-               s_inc = -2;

-            }

-

-            shift = s_start;

-

-            for (i = 0; i < row_width; i++)

-            {

-               if (m & mask)

-               {

-                  value = (*sp >> shift) & 0x03;

-                  *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                  *dp |= (png_byte)(value << shift);

-               }

-

-               if (shift == s_end)

-               {

-                  shift = s_start;

-                  sp++;

-                  dp++;

-               }

-               else

-                  shift += s_inc;

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

-            }

-            break;

-         }

-         case 4:

-         {

-            png_bytep sp = png_ptr->row_buf + 1;

-            png_bytep dp = row;

-            int s_start, s_end, s_inc;

-            int m = 0x80;

-            int shift;

-            png_uint_32 i;

-            png_uint_32 row_width = png_ptr->width;

-            int value;

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (png_ptr->transformations & PNG_PACKSWAP)

-            {

-               s_start = 0;

-               s_end = 4;

-               s_inc = 4;

-            }

-            else

-#endif

-            {

-               s_start = 4;

-               s_end = 0;

-               s_inc = -4;

-            }

-            shift = s_start;

-

-            for (i = 0; i < row_width; i++)

-            {

-               if (m & mask)

-               {

-                  value = (*sp >> shift) & 0xf;

-                  *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                  *dp |= (png_byte)(value << shift);

-               }

-

-               if (shift == s_end)

-               {

-                  shift = s_start;

-                  sp++;

-                  dp++;

-               }

-               else

-                  shift += s_inc;

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

-            }

-            break;

-         }

-         default:

-         {

-            png_bytep sp = png_ptr->row_buf + 1;

-            png_bytep dp = row;

-            png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

-            png_uint_32 i;

-            png_uint_32 row_width = png_ptr->width;

-            png_byte m = 0x80;

-

-

-            for (i = 0; i < row_width; i++)

-            {

-               if (m & mask)

-               {

-                  png_memcpy(dp, sp, pixel_bytes);

-               }

-

-               sp += pixel_bytes;

-               dp += pixel_bytes;

-

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

-            }

-            break;

-         }

-      }

-   }

-}

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-/* OLD pre-1.0.9 interface:

-void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,

-   png_uint_32 transformations)

- */

-void /* PRIVATE */

-png_do_read_interlace(png_structp png_ptr)

-{

-   png_row_infop row_info = &(png_ptr->row_info);

-   png_bytep row = png_ptr->row_buf + 1;

-   int pass = png_ptr->pass;

-   png_uint_32 transformations = png_ptr->transformations;

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-   /* Offset to next interlace block */

-   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

-

-   png_debug(1, "in png_do_read_interlace");

-   if (row != NULL && row_info != NULL)

-   {

-      png_uint_32 final_width;

-

-      final_width = row_info->width * png_pass_inc[pass];

-

-      switch (row_info->pixel_depth)

-      {

-         case 1:

-         {

-            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);

-            png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);

-            int sshift, dshift;

-            int s_start, s_end, s_inc;

-            int jstop = png_pass_inc[pass];

-            png_byte v;

-            png_uint_32 i;

-            int j;

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (transformations & PNG_PACKSWAP)

-            {

-                sshift = (int)((row_info->width + 7) & 0x07);

-                dshift = (int)((final_width + 7) & 0x07);

-                s_start = 7;

-                s_end = 0;

-                s_inc = -1;

-            }

-            else

-#endif

-            {

-                sshift = 7 - (int)((row_info->width + 7) & 0x07);

-                dshift = 7 - (int)((final_width + 7) & 0x07);

-                s_start = 0;

-                s_end = 7;

-                s_inc = 1;

-            }

-

-            for (i = 0; i < row_info->width; i++)

-            {

-               v = (png_byte)((*sp >> sshift) & 0x01);

-               for (j = 0; j < jstop; j++)

-               {

-                  *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);

-                  *dp |= (png_byte)(v << dshift);

-                  if (dshift == s_end)

-                  {

-                     dshift = s_start;

-                     dp--;

-                  }

-                  else

-                     dshift += s_inc;

-               }

-               if (sshift == s_end)

-               {

-                  sshift = s_start;

-                  sp--;

-               }

-               else

-                  sshift += s_inc;

-            }

-            break;

-         }

-         case 2:

-         {

-            png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);

-            png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);

-            int sshift, dshift;

-            int s_start, s_end, s_inc;

-            int jstop = png_pass_inc[pass];

-            png_uint_32 i;

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (transformations & PNG_PACKSWAP)

-            {

-               sshift = (int)(((row_info->width + 3) & 0x03) << 1);

-               dshift = (int)(((final_width + 3) & 0x03) << 1);

-               s_start = 6;

-               s_end = 0;

-               s_inc = -2;

-            }

-            else

-#endif

-            {

-               sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);

-               dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);

-               s_start = 0;

-               s_end = 6;

-               s_inc = 2;

-            }

-

-            for (i = 0; i < row_info->width; i++)

-            {

-               png_byte v;

-               int j;

-

-               v = (png_byte)((*sp >> sshift) & 0x03);

-               for (j = 0; j < jstop; j++)

-               {

-                  *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);

-                  *dp |= (png_byte)(v << dshift);

-                  if (dshift == s_end)

-                  {

-                     dshift = s_start;

-                     dp--;

-                  }

-                  else

-                     dshift += s_inc;

-               }

-               if (sshift == s_end)

-               {

-                  sshift = s_start;

-                  sp--;

-               }

-               else

-                  sshift += s_inc;

-            }

-            break;

-         }

-         case 4:

-         {

-            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);

-            png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);

-            int sshift, dshift;

-            int s_start, s_end, s_inc;

-            png_uint_32 i;

-            int jstop = png_pass_inc[pass];

-

-#ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (transformations & PNG_PACKSWAP)

-            {

-               sshift = (int)(((row_info->width + 1) & 0x01) << 2);

-               dshift = (int)(((final_width + 1) & 0x01) << 2);

-               s_start = 4;

-               s_end = 0;

-               s_inc = -4;

-            }

-            else

-#endif

-            {

-               sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);

-               dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);

-               s_start = 0;

-               s_end = 4;

-               s_inc = 4;

-            }

-

-            for (i = 0; i < row_info->width; i++)

-            {

-               png_byte v = (png_byte)((*sp >> sshift) & 0xf);

-               int j;

-

-               for (j = 0; j < jstop; j++)

-               {

-                  *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);

-                  *dp |= (png_byte)(v << dshift);

-                  if (dshift == s_end)

-                  {

-                     dshift = s_start;

-                     dp--;

-                  }

-                  else

-                     dshift += s_inc;

-               }

-               if (sshift == s_end)

-               {

-                  sshift = s_start;

-                  sp--;

-               }

-               else

-                  sshift += s_inc;

-            }

-            break;

-         }

-         default:

-         {

-            png_size_t pixel_bytes = (row_info->pixel_depth >> 3);

-            png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;

-            png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;

-

-            int jstop = png_pass_inc[pass];

-            png_uint_32 i;

-

-            for (i = 0; i < row_info->width; i++)

-            {

-               png_byte v[8];

-               int j;

-

-               png_memcpy(v, sp, pixel_bytes);

-               for (j = 0; j < jstop; j++)

-               {

-                  png_memcpy(dp, v, pixel_bytes);

-                  dp -= pixel_bytes;

-               }

-               sp -= pixel_bytes;

-            }

-            break;

-         }

-      }

-      row_info->width = final_width;

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);

-   }

-#ifndef PNG_READ_PACKSWAP_SUPPORTED

-   transformations = transformations; /* Silence compiler warning */

-#endif

-}

-#endif /* PNG_READ_INTERLACING_SUPPORTED */

-

-void /* PRIVATE */

-png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,

-   png_bytep prev_row, int filter)

-{

-   png_debug(1, "in png_read_filter_row");

-   png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);

-   switch (filter)

-   {

-      case PNG_FILTER_VALUE_NONE:

-         break;

-      case PNG_FILTER_VALUE_SUB:

-      {

-         png_uint_32 i;

-         png_uint_32 istop = row_info->rowbytes;

-         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

-         png_bytep rp = row + bpp;

-         png_bytep lp = row;

-

-         for (i = bpp; i < istop; i++)

-         {

-            *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);

-            rp++;

-         }

-         break;

-      }

-      case PNG_FILTER_VALUE_UP:

-      {

-         png_uint_32 i;

-         png_uint_32 istop = row_info->rowbytes;

-         png_bytep rp = row;

-         png_bytep pp = prev_row;

-

-         for (i = 0; i < istop; i++)

-         {

-            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

-            rp++;

-         }

-         break;

-      }

-      case PNG_FILTER_VALUE_AVG:

-      {

-         png_uint_32 i;

-         png_bytep rp = row;

-         png_bytep pp = prev_row;

-         png_bytep lp = row;

-         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

-         png_uint_32 istop = row_info->rowbytes - bpp;

-

-         for (i = 0; i < bpp; i++)

-         {

-            *rp = (png_byte)(((int)(*rp) +

-               ((int)(*pp++) / 2 )) & 0xff);

-            rp++;

-         }

-

-         for (i = 0; i < istop; i++)

-         {

-            *rp = (png_byte)(((int)(*rp) +

-               (int)(*pp++ + *lp++) / 2 ) & 0xff);

-            rp++;

-         }

-         break;

-      }

-      case PNG_FILTER_VALUE_PAETH:

-      {

-         png_uint_32 i;

-         png_bytep rp = row;

-         png_bytep pp = prev_row;

-         png_bytep lp = row;

-         png_bytep cp = prev_row;

-         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

-         png_uint_32 istop=row_info->rowbytes - bpp;

-

-         for (i = 0; i < bpp; i++)

-         {

-            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

-            rp++;

-         }

-

-         for (i = 0; i < istop; i++)   /* Use leftover rp,pp */

-         {

-            int a, b, c, pa, pb, pc, p;

-

-            a = *lp++;

-            b = *pp++;

-            c = *cp++;

-

-            p = b - c;

-            pc = a - c;

-

-#ifdef PNG_USE_ABS

-            pa = abs(p);

-            pb = abs(pc);

-            pc = abs(p + pc);

-#else

-            pa = p < 0 ? -p : p;

-            pb = pc < 0 ? -pc : pc;

-            pc = (p + pc) < 0 ? -(p + pc) : p + pc;

-#endif

-

-            /*

-               if (pa <= pb && pa <= pc)

-                  p = a;

-               else if (pb <= pc)

-                  p = b;

-               else

-                  p = c;

-             */

-

-            p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;

-

-            *rp = (png_byte)(((int)(*rp) + p) & 0xff);

-            rp++;

-         }

-         break;

-      }

-      default:

-         png_warning(png_ptr, "Ignoring bad adaptive filter type");

-         *row = 0;

-         break;

-   }

-}

-

-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-void /* PRIVATE */

-png_read_finish_row(png_structp png_ptr)

-{

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-

-   /* Start of interlace block */

-   PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

-

-   /* Offset to next interlace block */

-   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

-

-   /* Start of interlace block in the y direction */

-   PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

-

-   /* Offset to next interlace block in the y direction */

-   PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

-#endif /* PNG_READ_INTERLACING_SUPPORTED */

-

-   png_debug(1, "in png_read_finish_row");

-   png_ptr->row_number++;

-   if (png_ptr->row_number < png_ptr->num_rows)

-      return;

-

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   if (png_ptr->interlaced)

-   {

-      png_ptr->row_number = 0;

-      png_memset_check(png_ptr, png_ptr->prev_row, 0,

-         png_ptr->rowbytes + 1);

-      do

-      {

-         png_ptr->pass++;

-         if (png_ptr->pass >= 7)

-            break;

-         png_ptr->iwidth = (png_ptr->width +

-            png_pass_inc[png_ptr->pass] - 1 -

-            png_pass_start[png_ptr->pass]) /

-            png_pass_inc[png_ptr->pass];

-

-         png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,

-            png_ptr->iwidth) + 1;

-

-         if (!(png_ptr->transformations & PNG_INTERLACE))

-         {

-            png_ptr->num_rows = (png_ptr->height +

-               png_pass_yinc[png_ptr->pass] - 1 -

-               png_pass_ystart[png_ptr->pass]) /

-               png_pass_yinc[png_ptr->pass];

-            if (!(png_ptr->num_rows))

-               continue;

-         }

-         else  /* if (png_ptr->transformations & PNG_INTERLACE) */

-            break;

-      } while (png_ptr->iwidth == 0);

-

-      if (png_ptr->pass < 7)

-         return;

-   }

-#endif /* PNG_READ_INTERLACING_SUPPORTED */

-

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

-   {

-#ifdef PNG_USE_LOCAL_ARRAYS

-      PNG_CONST PNG_IDAT;

-#endif

-      char extra;

-      int ret;

-

-      png_ptr->zstream.next_out = (Byte *)&extra;

-      png_ptr->zstream.avail_out = (uInt)1;

-      for (;;)

-      {

-         if (!(png_ptr->zstream.avail_in))

-         {

-            while (!png_ptr->idat_size)

-            {

-               png_byte chunk_length[4];

-

-               png_crc_finish(png_ptr, 0);

-

-               png_read_data(png_ptr, chunk_length, 4);

-               png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);

-               png_reset_crc(png_ptr);

-               png_crc_read(png_ptr, png_ptr->chunk_name, 4);

-               if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-                  png_error(png_ptr, "Not enough image data");

-

-            }

-            png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

-            png_ptr->zstream.next_in = png_ptr->zbuf;

-            if (png_ptr->zbuf_size > png_ptr->idat_size)

-               png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

-            png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);

-            png_ptr->idat_size -= png_ptr->zstream.avail_in;

-         }

-         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-         if (ret == Z_STREAM_END)

-         {

-            if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||

-               png_ptr->idat_size)

-               png_warning(png_ptr, "Extra compressed data");

-            png_ptr->mode |= PNG_AFTER_IDAT;

-            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-            break;

-         }

-         if (ret != Z_OK)

-            png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

-                      "Decompression Error");

-

-         if (!(png_ptr->zstream.avail_out))

-         {

-            png_warning(png_ptr, "Extra compressed data.");

-            png_ptr->mode |= PNG_AFTER_IDAT;

-            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-            break;

-         }

-

-      }

-      png_ptr->zstream.avail_out = 0;

-   }

-

-   if (png_ptr->idat_size || png_ptr->zstream.avail_in)

-      png_warning(png_ptr, "Extra compression data");

-

-   inflateReset(&png_ptr->zstream);

-

-   png_ptr->mode |= PNG_AFTER_IDAT;

-}

-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

-

-void /* PRIVATE */

-png_read_start_row(png_structp png_ptr)

-{

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-

-   /* Start of interlace block */

-   PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

-

-   /* Offset to next interlace block */

-   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

-

-   /* Start of interlace block in the y direction */

-   PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

-

-   /* Offset to next interlace block in the y direction */

-   PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

-#endif

-

-   int max_pixel_depth;

-   png_size_t row_bytes;

-

-   png_debug(1, "in png_read_start_row");

-   png_ptr->zstream.avail_in = 0;

-   png_init_read_transformations(png_ptr);

-#ifdef PNG_READ_INTERLACING_SUPPORTED

-   if (png_ptr->interlaced)

-   {

-      if (!(png_ptr->transformations & PNG_INTERLACE))

-         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

-            png_pass_ystart[0]) / png_pass_yinc[0];

-      else

-         png_ptr->num_rows = png_ptr->height;

-

-      png_ptr->iwidth = (png_ptr->width +

-         png_pass_inc[png_ptr->pass] - 1 -

-         png_pass_start[png_ptr->pass]) /

-         png_pass_inc[png_ptr->pass];

-

-         png_ptr->irowbytes =

-            PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1;

-   }

-   else

-#endif /* PNG_READ_INTERLACING_SUPPORTED */

-   {

-      png_ptr->num_rows = png_ptr->height;

-      png_ptr->iwidth = png_ptr->width;

-      png_ptr->irowbytes = png_ptr->rowbytes + 1;

-   }

-   max_pixel_depth = png_ptr->pixel_depth;

-

-#ifdef PNG_READ_PACK_SUPPORTED

-   if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)

-      max_pixel_depth = 8;

-#endif

-

-#ifdef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr->transformations & PNG_EXPAND)

-   {

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         if (png_ptr->num_trans)

-            max_pixel_depth = 32;

-         else

-            max_pixel_depth = 24;

-      }

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         if (max_pixel_depth < 8)

-            max_pixel_depth = 8;

-         if (png_ptr->num_trans)

-            max_pixel_depth *= 2;

-      }

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-      {

-         if (png_ptr->num_trans)

-         {

-            max_pixel_depth *= 4;

-            max_pixel_depth /= 3;

-         }

-      }

-   }

-#endif

-

-#ifdef PNG_READ_FILLER_SUPPORTED

-   if (png_ptr->transformations & (PNG_FILLER))

-   {

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-         max_pixel_depth = 32;

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         if (max_pixel_depth <= 8)

-            max_pixel_depth = 16;

-         else

-            max_pixel_depth = 32;

-      }

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-      {

-         if (max_pixel_depth <= 32)

-            max_pixel_depth = 32;

-         else

-            max_pixel_depth = 64;

-      }

-   }

-#endif

-

-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   if (png_ptr->transformations & PNG_GRAY_TO_RGB)

-   {

-      if (

-#ifdef PNG_READ_EXPAND_SUPPORTED

-        (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||

-#endif

-#ifdef PNG_READ_FILLER_SUPPORTED

-        (png_ptr->transformations & (PNG_FILLER)) ||

-#endif

-        png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         if (max_pixel_depth <= 16)

-            max_pixel_depth = 32;

-         else

-            max_pixel_depth = 64;

-      }

-      else

-      {

-         if (max_pixel_depth <= 8)

-           {

-             if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-               max_pixel_depth = 32;

-             else

-               max_pixel_depth = 24;

-           }

-         else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-            max_pixel_depth = 64;

-         else

-            max_pixel_depth = 48;

-      }

-   }

-#endif

-

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \

-defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

-     {

-       int user_pixel_depth = png_ptr->user_transform_depth*

-         png_ptr->user_transform_channels;

-       if (user_pixel_depth > max_pixel_depth)

-         max_pixel_depth=user_pixel_depth;

-     }

-#endif

-

-   /* Align the width on the next larger 8 pixels.  Mainly used

-    * for interlacing

-    */

-   row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));

-   /* Calculate the maximum bytes needed, adding a byte and a pixel

-    * for safety's sake

-    */

-   row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +

-      1 + ((max_pixel_depth + 7) >> 3);

-#ifdef PNG_MAX_MALLOC_64K

-   if (row_bytes > (png_uint_32)65536L)

-      png_error(png_ptr, "This image requires a row greater than 64KB");

-#endif

-

-   if (row_bytes + 64 > png_ptr->old_big_row_buf_size)

-   {

-     png_free(png_ptr, png_ptr->big_row_buf);

-     if (png_ptr->interlaced)

-        png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr, row_bytes + 64);

-     else

-        png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 64);

-     png_ptr->row_buf = png_ptr->big_row_buf + 32;

-     png_ptr->old_big_row_buf_size = row_bytes + 64;

-   }

-

-#ifdef PNG_MAX_MALLOC_64K

-   if ((png_uint_32)row_bytes + 1 > (png_uint_32)65536L)

-      png_error(png_ptr, "This image requires a row greater than 64KB");

-#endif

-   if ((png_uint_32)row_bytes > (png_uint_32)(PNG_SIZE_MAX - 1))

-      png_error(png_ptr, "Row has too many bytes to allocate in memory.");

-

-   if (row_bytes + 1 > png_ptr->old_prev_row_size)

-   {

-      png_free(png_ptr, png_ptr->prev_row);

-      png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(

-        row_bytes + 1));

-      png_memset_check(png_ptr, png_ptr->prev_row, 0, row_bytes + 1);

-      png_ptr->old_prev_row_size = row_bytes + 1;

-   }

-

-   png_ptr->rowbytes = row_bytes;

-

-   png_debug1(3, "width = %lu,", png_ptr->width);

-   png_debug1(3, "height = %lu,", png_ptr->height);

-   png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);

-   png_debug1(3, "num_rows = %lu,", png_ptr->num_rows);

-   png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);

-   png_debug1(3, "irowbytes = %lu", png_ptr->irowbytes);

-

-   png_ptr->flags |= PNG_FLAG_ROW_INIT;

-}

-#endif /* PNG_READ_SUPPORTED */

+
+/* pngrutil.c - utilities to read a PNG file
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file contains routines that are only called from within
+ * libpng itself during the course of reading an image.
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_READ_SUPPORTED
+#include "pngpriv.h"
+
+#    define png_strtod(p,a,b) strtod(a,b)
+png_uint_32 PNGAPI
+png_get_uint_31(png_structp png_ptr, png_bytep buf)
+{
+   png_uint_32 i = png_get_uint_32(buf);
+   if (i > PNG_UINT_31_MAX)
+     png_error(png_ptr, "PNG unsigned integer out of range");
+   return (i);
+}
+#ifndef PNG_USE_READ_MACROS
+/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */
+png_uint_32 PNGAPI
+png_get_uint_32(png_bytep buf)
+{
+   png_uint_32 i = ((png_uint_32)(*buf) << 24) +
+      ((png_uint_32)(*(buf + 1)) << 16) +
+      ((png_uint_32)(*(buf + 2)) << 8) +
+      (png_uint_32)(*(buf + 3));
+
+   return (i);
+}
+
+/* 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
+ * assumed that the machine format for signed integers is the same.
+ */
+png_int_32 PNGAPI
+png_get_int_32(png_bytep buf)
+{
+   png_int_32 i = ((png_int_32)(*buf) << 24) +
+      ((png_int_32)(*(buf + 1)) << 16) +
+      ((png_int_32)(*(buf + 2)) << 8) +
+      (png_int_32)(*(buf + 3));
+
+   return (i);
+}
+
+/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */
+png_uint_16 PNGAPI
+png_get_uint_16(png_bytep buf)
+{
+   png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
+      (png_uint_16)(*(buf + 1)));
+
+   return (i);
+}
+#endif /* PNG_USE_READ_MACROS */
+
+/* Read the chunk header (length + type name).
+ * Put the type name into png_ptr->chunk_name, and return the length.
+ */
+png_uint_32 /* PRIVATE */
+png_read_chunk_header(png_structp png_ptr)
+{
+   png_byte buf[8];
+   png_uint_32 length;
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   /* Inform the I/O callback that the chunk header is being read.
+    * PNG_IO_CHUNK_HDR requires a single I/O call.
+    */
+   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;
+#endif
+
+   /* Read the length and the chunk name */
+   png_read_data(png_ptr, buf, 8);
+   length = png_get_uint_31(png_ptr, buf);
+
+   /* Put the chunk name into png_ptr->chunk_name */
+   png_memcpy(png_ptr->chunk_name, buf + 4, 4);
+
+   png_debug2(0, "Reading %s chunk, length = %lu",
+      png_ptr->chunk_name, length);
+
+   /* Reset the crc and run it over the chunk name */
+   png_reset_crc(png_ptr);
+   png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
+
+   /* Check to see if chunk name is valid */
+   png_check_chunk_name(png_ptr, png_ptr->chunk_name);
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   /* Inform the I/O callback that chunk data will (possibly) be read.
+    * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.
+    */
+   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;
+#endif
+
+   return length;
+}
+
+/* Read data, and (optionally) run it through the CRC. */
+void /* PRIVATE */
+png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
+{
+   if (png_ptr == NULL)
+      return;
+   png_read_data(png_ptr, buf, length);
+   png_calculate_crc(png_ptr, buf, length);
+}
+
+/* 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
+ * things up, we may calculate the CRC on the data and print a message.
+ * Returns '1' if there was a CRC error, '0' otherwise.
+ */
+int /* PRIVATE */
+png_crc_finish(png_structp png_ptr, png_uint_32 skip)
+{
+   png_size_t i;
+   png_size_t istop = png_ptr->zbuf_size;
+
+   for (i = (png_size_t)skip; i > istop; i -= istop)
+   {
+      png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+   }
+   if (i)
+   {
+      png_crc_read(png_ptr, png_ptr->zbuf, i);
+   }
+
+   if (png_crc_error(png_ptr))
+   {
+      if (((png_ptr->chunk_name[0] & 0x20) &&                /* Ancillary */
+          !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
+          (!(png_ptr->chunk_name[0] & 0x20) &&             /* Critical  */
+          (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
+      {
+         png_chunk_warning(png_ptr, "CRC error");
+      }
+      else
+      {
+         png_chunk_benign_error(png_ptr, "CRC error");
+         return (0);
+      }
+      return (1);
+   }
+
+   return (0);
+}
+
+/* Compare the CRC stored in the PNG file with that calculated by libpng from
+ * the data it has read thus far.
+ */
+int /* PRIVATE */
+png_crc_error(png_structp png_ptr)
+{
+   png_byte crc_bytes[4];
+   png_uint_32 crc;
+   int need_crc = 1;
+
+   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
+   {
+      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
+          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
+         need_crc = 0;
+   }
+   else                                                    /* critical */
+   {
+      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
+         need_crc = 0;
+   }
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   /* Inform the I/O callback that the chunk CRC is being read */
+   /* PNG_IO_CHUNK_CRC requires the I/O to be done at once */
+   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;
+#endif
+
+   png_read_data(png_ptr, crc_bytes, 4);
+
+   if (need_crc)
+   {
+      crc = png_get_uint_32(crc_bytes);
+      return ((int)(crc != png_ptr->crc));
+   }
+   else
+      return (0);
+}
+
+#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \
+    defined(PNG_READ_iCCP_SUPPORTED)
+/*
+ * Decompress trailing data in a chunk.  The assumption is that chunkdata
+ * points at an allocated area holding the contents of a chunk with a
+ * trailing compressed part.  What we get back is an allocated area
+ * holding the original prefix part and an uncompressed version of the
+ * trailing part (the malloc area passed in is freed).
+ */
+void /* PRIVATE */
+png_decompress_chunk(png_structp png_ptr, int comp_type,
+                              png_size_t chunklength,
+                              png_size_t prefix_size, png_size_t *newlength)
+{
+   static PNG_CONST char msg[] = "Error decoding compressed chunk";
+   png_charp text;
+   png_size_t text_size;
+
+   if (comp_type == PNG_COMPRESSION_TYPE_BASE)
+   {
+      int ret = Z_OK;
+      png_ptr->zstream.next_in = (png_bytep)(png_ptr->chunkdata + prefix_size);
+      png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size);
+      png_ptr->zstream.next_out = png_ptr->zbuf;
+      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+
+      text_size = 0;
+      text = NULL;
+
+      while (png_ptr->zstream.avail_in)
+      {
+         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+         if (ret != Z_OK && ret != Z_STREAM_END)
+         {
+            if (png_ptr->zstream.msg != NULL)
+               png_warning(png_ptr, png_ptr->zstream.msg);
+            else
+               png_warning(png_ptr, msg);
+            inflateReset(&png_ptr->zstream);
+            png_ptr->zstream.avail_in = 0;
+
+            if (text ==  NULL)
+            {
+               text_size = prefix_size + png_sizeof(msg) + 1;
+               text = (png_charp)png_malloc_warn(png_ptr, text_size);
+               if (text ==  NULL)
+                 {
+                    png_free(png_ptr, png_ptr->chunkdata);
+                    png_ptr->chunkdata = NULL;
+                    png_error(png_ptr, "Not enough memory to decompress chunk");
+                 }
+               png_memcpy(text, png_ptr->chunkdata, prefix_size);
+            }
+
+            text[text_size - 1] = 0x00;
+
+            /* Copy what we can of the error message into the text chunk */
+            text_size = (png_size_t)(chunklength -
+              (text - png_ptr->chunkdata) - 1);
+            if (text_size > png_sizeof(msg))
+               text_size = png_sizeof(msg);
+            png_memcpy(text + prefix_size, msg, text_size);
+            break;
+         }
+         if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END)
+         {
+            if (text == NULL)
+            {
+               text_size = prefix_size +
+                   png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+               text = (png_charp)png_malloc_warn(png_ptr, text_size + 1);
+               if (text ==  NULL)
+               {
+                  png_free(png_ptr, png_ptr->chunkdata);
+                  png_ptr->chunkdata = NULL;
+                  png_error(png_ptr,
+                    "Not enough memory to decompress chunk");
+               }
+               png_memcpy(text + prefix_size, png_ptr->zbuf,
+                    text_size - prefix_size);
+               png_memcpy(text, png_ptr->chunkdata, prefix_size);
+               *(text + text_size) = 0x00;
+            }
+            else
+            {
+               png_charp tmp;
+
+               tmp = text;
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+               if ((png_ptr->user_chunk_cache_max != 0) &&
+                  (--png_ptr->user_chunk_cache_max == 0))
+               {
+                  png_warning(png_ptr, "No space in chunk cache");
+                  text = NULL;
+               }
+
+               else
+               {
+#endif
+                  text = (png_charp)png_malloc_warn(png_ptr,
+                     (png_size_t)(text_size +
+                      png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1));
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+               }
+#endif
+               if (text == NULL)
+               {
+                  png_free(png_ptr, tmp);
+                  png_free(png_ptr, png_ptr->chunkdata);
+                  png_ptr->chunkdata = NULL;
+                  png_error(png_ptr,
+                    "Not enough memory to decompress chunk");
+               }
+               png_memcpy(text, tmp, text_size);
+               png_free(png_ptr, tmp);
+               png_memcpy(text + text_size, png_ptr->zbuf,
+                  (png_ptr->zbuf_size - png_ptr->zstream.avail_out));
+               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+               *(text + text_size) = 0x00;
+            }
+            if (ret == Z_STREAM_END)
+               break;
+            else
+            {
+               png_ptr->zstream.next_out = png_ptr->zbuf;
+               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+            }
+         }
+      }
+      if (ret != Z_STREAM_END)
+      {
+#ifdef PNG_STDIO_SUPPORTED
+         char umsg[52];
+
+         if (ret == Z_BUF_ERROR)
+            png_snprintf(umsg, 52,
+                "Buffer error in compressed datastream in %s chunk",
+                png_ptr->chunk_name);
+
+         else if (ret == Z_DATA_ERROR)
+            png_snprintf(umsg, 52,
+                "Data error in compressed datastream in %s chunk",
+                png_ptr->chunk_name);
+
+         else
+            png_snprintf(umsg, 52,
+                "Incomplete compressed datastream in %s chunk",
+                png_ptr->chunk_name);
+
+         png_warning(png_ptr, umsg);
+#else
+         png_warning(png_ptr,
+            "Incomplete compressed datastream in chunk other than IDAT");
+#endif
+         text_size = prefix_size;
+         if (text ==  NULL)
+         {
+            text = (png_charp)png_malloc_warn(png_ptr, text_size+1);
+            if (text == NULL)
+              {
+                png_free(png_ptr, png_ptr->chunkdata);
+                png_ptr->chunkdata = NULL;
+                png_error(png_ptr, "Not enough memory for text");
+              }
+            png_memcpy(text, png_ptr->chunkdata, prefix_size);
+         }
+         *(text + text_size) = 0x00;
+      }
+
+      inflateReset(&png_ptr->zstream);
+      png_ptr->zstream.avail_in = 0;
+
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = text;
+      *newlength=text_size;
+   }
+   else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */
+   {
+#ifdef PNG_STDIO_SUPPORTED
+      char umsg[50];
+
+      png_snprintf(umsg, 50, "Unknown zTXt compression type %d", comp_type);
+      png_warning(png_ptr, umsg);
+#else
+      png_warning(png_ptr, "Unknown zTXt compression type");
+#endif
+
+      *(png_ptr->chunkdata + prefix_size) = 0x00;
+      *newlength = prefix_size;
+   }
+}
+#endif
+
+/* Read and check the IDHR chunk */
+void /* PRIVATE */
+png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_byte buf[13];
+   png_uint_32 width, height;
+   int bit_depth, color_type, compression_type, filter_type;
+   int interlace_type;
+
+   png_debug(1, "in png_handle_IHDR");
+
+   if (png_ptr->mode & PNG_HAVE_IHDR)
+      png_error(png_ptr, "Out of place IHDR");
+
+   /* Check the length */
+   if (length != 13)
+      png_error(png_ptr, "Invalid IHDR chunk");
+
+   png_ptr->mode |= PNG_HAVE_IHDR;
+
+   png_crc_read(png_ptr, buf, 13);
+   png_crc_finish(png_ptr, 0);
+
+   width = png_get_uint_31(png_ptr, buf);
+   height = png_get_uint_31(png_ptr, buf + 4);
+   bit_depth = buf[8];
+   color_type = buf[9];
+   compression_type = buf[10];
+   filter_type = buf[11];
+   interlace_type = buf[12];
+
+   /* Set internal variables */
+   png_ptr->width = width;
+   png_ptr->height = height;
+   png_ptr->bit_depth = (png_byte)bit_depth;
+   png_ptr->interlaced = (png_byte)interlace_type;
+   png_ptr->color_type = (png_byte)color_type;
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   png_ptr->filter_type = (png_byte)filter_type;
+#endif
+   png_ptr->compression_type = (png_byte)compression_type;
+
+   /* Find number of channels */
+   switch (png_ptr->color_type)
+   {
+      case PNG_COLOR_TYPE_GRAY:
+      case PNG_COLOR_TYPE_PALETTE:
+         png_ptr->channels = 1;
+         break;
+
+      case PNG_COLOR_TYPE_RGB:
+         png_ptr->channels = 3;
+         break;
+
+      case PNG_COLOR_TYPE_GRAY_ALPHA:
+         png_ptr->channels = 2;
+         break;
+
+      case PNG_COLOR_TYPE_RGB_ALPHA:
+         png_ptr->channels = 4;
+         break;
+   }
+
+   /* Set up other useful info */
+   png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
+   png_ptr->channels);
+   png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
+   png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
+   png_debug1(3, "channels = %d", png_ptr->channels);
+   png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);
+   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
+      color_type, interlace_type, compression_type, filter_type);
+}
+
+/* Read and check the palette */
+void /* PRIVATE */
+png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_color palette[PNG_MAX_PALETTE_LENGTH];
+   int num, i;
+#ifdef PNG_POINTER_INDEXING_SUPPORTED
+   png_colorp pal_ptr;
+#endif
+
+   png_debug(1, "in png_handle_PLTE");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before PLTE");
+
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid PLTE after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      png_error(png_ptr, "Duplicate PLTE chunk");
+
+   png_ptr->mode |= PNG_HAVE_PLTE;
+
+   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
+   {
+      png_warning(png_ptr,
+        "Ignoring PLTE chunk in grayscale PNG");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+#ifndef PNG_READ_OPT_PLTE_SUPPORTED
+   if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+   {
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+#endif
+
+   if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)
+   {
+      if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+      {
+         png_warning(png_ptr, "Invalid palette chunk");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+
+      else
+      {
+         png_error(png_ptr, "Invalid palette chunk");
+      }
+   }
+
+   num = (int)length / 3;
+
+#ifdef PNG_POINTER_INDEXING_SUPPORTED
+   for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)
+   {
+      png_byte buf[3];
+
+      png_crc_read(png_ptr, buf, 3);
+      pal_ptr->red = buf[0];
+      pal_ptr->green = buf[1];
+      pal_ptr->blue = buf[2];
+   }
+#else
+   for (i = 0; i < num; i++)
+   {
+      png_byte buf[3];
+
+      png_crc_read(png_ptr, buf, 3);
+      /* Don't depend upon png_color being any order */
+      palette[i].red = buf[0];
+      palette[i].green = buf[1];
+      palette[i].blue = buf[2];
+   }
+#endif
+
+   /* If we actually NEED the PLTE chunk (ie for a paletted image), we do
+    * whatever the normal CRC configuration tells us.  However, if we
+    * have an RGB image, the PLTE can be considered ancillary, so
+    * we will act as though it is.
+    */
+#ifndef PNG_READ_OPT_PLTE_SUPPORTED
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+#endif
+   {
+      png_crc_finish(png_ptr, 0);
+   }
+#ifndef PNG_READ_OPT_PLTE_SUPPORTED
+   else if (png_crc_error(png_ptr))  /* Only if we have a CRC error */
+   {
+      /* If we don't want to use the data from an ancillary chunk,
+         we have two options: an error abort, or a warning and we
+         ignore the data in this chunk (which should be OK, since
+         it's considered ancillary for a RGB or RGBA image). */
+      if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
+      {
+         if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
+         {
+            png_chunk_benign_error(png_ptr, "CRC error");
+         }
+         else
+         {
+            png_chunk_warning(png_ptr, "CRC error");
+            return;
+         }
+      }
+      /* Otherwise, we (optionally) emit a warning and use the chunk. */
+      else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
+      {
+         png_chunk_warning(png_ptr, "CRC error");
+      }
+   }
+#endif
+
+   png_set_PLTE(png_ptr, info_ptr, palette, num);
+
+#ifdef PNG_READ_tRNS_SUPPORTED
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
+      {
+         if (png_ptr->num_trans > (png_uint_16)num)
+         {
+            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
+            png_ptr->num_trans = (png_uint_16)num;
+         }
+         if (info_ptr->num_trans > (png_uint_16)num)
+         {
+            png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
+            info_ptr->num_trans = (png_uint_16)num;
+         }
+      }
+   }
+#endif
+
+}
+
+void /* PRIVATE */
+png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_debug(1, "in png_handle_IEND");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
+   {
+      png_error(png_ptr, "No image in file");
+   }
+
+   png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
+
+   if (length != 0)
+   {
+      png_warning(png_ptr, "Incorrect IEND chunk length");
+   }
+   png_crc_finish(png_ptr, length);
+
+   info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */
+}
+
+#ifdef PNG_READ_gAMA_SUPPORTED
+void /* PRIVATE */
+png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_fixed_point igamma;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   float file_gamma;
+#endif
+   png_byte buf[4];
+
+   png_debug(1, "in png_handle_gAMA");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before gAMA");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid gAMA after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Out of place gAMA chunk");
+
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+#ifdef PNG_READ_sRGB_SUPPORTED
+      && !(info_ptr->valid & PNG_INFO_sRGB)
+#endif
+      )
+   {
+      png_warning(png_ptr, "Duplicate gAMA chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (length != 4)
+   {
+      png_warning(png_ptr, "Incorrect gAMA chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, 4);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   igamma = (png_fixed_point)png_get_uint_32(buf);
+   /* Check for zero gamma */
+   if (igamma == 0)
+      {
+         png_warning(png_ptr,
+           "Ignoring gAMA chunk with gamma=0");
+         return;
+      }
+
+#ifdef PNG_READ_sRGB_SUPPORTED
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))
+      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))
+      {
+         png_warning(png_ptr,
+           "Ignoring incorrect gAMA value when sRGB is also present");
+#ifdef PNG_CONSOLE_IO_SUPPORTED
+         fprintf(stderr, "gamma = (%d/100000)", (int)igamma);
+#endif
+         return;
+      }
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   file_gamma = (float)igamma / (float)100000.0;
+#  ifdef PNG_READ_GAMMA_SUPPORTED
+     png_ptr->gamma = file_gamma;
+#  endif
+     png_set_gAMA(png_ptr, info_ptr, file_gamma);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
+#endif
+}
+#endif
+
+#ifdef PNG_READ_sBIT_SUPPORTED
+void /* PRIVATE */
+png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_size_t truelen;
+   png_byte buf[4];
+
+   png_debug(1, "in png_handle_sBIT");
+
+   buf[0] = buf[1] = buf[2] = buf[3] = 0;
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before sBIT");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid sBIT after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+   {
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Out of place sBIT chunk");
+   }
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))
+   {
+      png_warning(png_ptr, "Duplicate sBIT chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      truelen = 3;
+   else
+      truelen = (png_size_t)png_ptr->channels;
+
+   if (length != truelen || length > 4)
+   {
+      png_warning(png_ptr, "Incorrect sBIT chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, truelen);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
+   {
+      png_ptr->sig_bit.red = buf[0];
+      png_ptr->sig_bit.green = buf[1];
+      png_ptr->sig_bit.blue = buf[2];
+      png_ptr->sig_bit.alpha = buf[3];
+   }
+   else
+   {
+      png_ptr->sig_bit.gray = buf[0];
+      png_ptr->sig_bit.red = buf[0];
+      png_ptr->sig_bit.green = buf[0];
+      png_ptr->sig_bit.blue = buf[0];
+      png_ptr->sig_bit.alpha = buf[1];
+   }
+   png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
+}
+#endif
+
+#ifdef PNG_READ_cHRM_SUPPORTED
+void /* PRIVATE */
+png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_byte buf[32];
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
+#endif
+   png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,
+      int_y_green, int_x_blue, int_y_blue;
+
+   png_uint_32 uint_x, uint_y;
+
+   png_debug(1, "in png_handle_cHRM");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before cHRM");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid cHRM after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Missing PLTE before cHRM");
+
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)
+#ifdef PNG_READ_sRGB_SUPPORTED
+      && !(info_ptr->valid & PNG_INFO_sRGB)
+#endif
+      )
+   {
+      png_warning(png_ptr, "Duplicate cHRM chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (length != 32)
+   {
+      png_warning(png_ptr, "Incorrect cHRM chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, 32);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   uint_x = png_get_uint_32(buf);
+   uint_y = png_get_uint_32(buf + 4);
+   int_x_white = (png_fixed_point)uint_x;
+   int_y_white = (png_fixed_point)uint_y;
+
+   uint_x = png_get_uint_32(buf + 8);
+   uint_y = png_get_uint_32(buf + 12);
+   int_x_red = (png_fixed_point)uint_x;
+   int_y_red = (png_fixed_point)uint_y;
+
+   uint_x = png_get_uint_32(buf + 16);
+   uint_y = png_get_uint_32(buf + 20);
+   int_x_green = (png_fixed_point)uint_x;
+   int_y_green = (png_fixed_point)uint_y;
+
+   uint_x = png_get_uint_32(buf + 24);
+   uint_y = png_get_uint_32(buf + 28);
+   int_x_blue = (png_fixed_point)uint_x;
+   int_y_blue = (png_fixed_point)uint_y;
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   white_x = (float)int_x_white / (float)100000.0;
+   white_y = (float)int_y_white / (float)100000.0;
+   red_x   = (float)int_x_red   / (float)100000.0;
+   red_y   = (float)int_y_red   / (float)100000.0;
+   green_x = (float)int_x_green / (float)100000.0;
+   green_y = (float)int_y_green / (float)100000.0;
+   blue_x  = (float)int_x_blue  / (float)100000.0;
+   blue_y  = (float)int_y_blue  / (float)100000.0;
+#endif
+
+#ifdef PNG_READ_sRGB_SUPPORTED
+   if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB))
+      {
+      if (PNG_OUT_OF_RANGE(int_x_white, 31270,  1000) ||
+          PNG_OUT_OF_RANGE(int_y_white, 32900,  1000) ||
+          PNG_OUT_OF_RANGE(int_x_red,   64000L, 1000) ||
+          PNG_OUT_OF_RANGE(int_y_red,   33000,  1000) ||
+          PNG_OUT_OF_RANGE(int_x_green, 30000,  1000) ||
+          PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) ||
+          PNG_OUT_OF_RANGE(int_x_blue,  15000,  1000) ||
+          PNG_OUT_OF_RANGE(int_y_blue,   6000,  1000))
+         {
+            png_warning(png_ptr,
+              "Ignoring incorrect cHRM value when sRGB is also present");
+#ifdef PNG_CONSOLE_IO_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+            fprintf(stderr, "wx=%f, wy=%f, rx=%f, ry=%f\n",
+               white_x, white_y, red_x, red_y);
+            fprintf(stderr, "gx=%f, gy=%f, bx=%f, by=%f\n",
+               green_x, green_y, blue_x, blue_y);
+#else
+            fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n",
+               int_x_white, int_y_white, int_x_red, int_y_red);
+            fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n",
+               int_x_green, int_y_green, int_x_blue, int_y_blue);
+#endif
+#endif /* PNG_CONSOLE_IO_SUPPORTED */
+         }
+         return;
+      }
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   png_set_cHRM(png_ptr, info_ptr,
+      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   png_set_cHRM_fixed(png_ptr, info_ptr,
+      int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,
+      int_y_green, int_x_blue, int_y_blue);
+#endif
+}
+#endif
+
+#ifdef PNG_READ_sRGB_SUPPORTED
+void /* PRIVATE */
+png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   int intent;
+   png_byte buf[1];
+
+   png_debug(1, "in png_handle_sRGB");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before sRGB");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid sRGB after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Out of place sRGB chunk");
+
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))
+   {
+      png_warning(png_ptr, "Duplicate sRGB chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (length != 1)
+   {
+      png_warning(png_ptr, "Incorrect sRGB chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, 1);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   intent = buf[0];
+   /* Check for bad intent */
+   if (intent >= PNG_sRGB_INTENT_LAST)
+   {
+      png_warning(png_ptr, "Unknown sRGB intent");
+      return;
+   }
+
+#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA))
+   {
+   png_fixed_point igamma;
+#ifdef PNG_FIXED_POINT_SUPPORTED
+      igamma=info_ptr->int_gamma;
+#else
+#  ifdef PNG_FLOATING_POINT_SUPPORTED
+      igamma=(png_fixed_point)(info_ptr->gamma * 100000.);
+#  endif
+#endif
+      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))
+      {
+         png_warning(png_ptr,
+           "Ignoring incorrect gAMA value when sRGB is also present");
+#ifdef PNG_CONSOLE_IO_SUPPORTED
+#  ifdef PNG_FIXED_POINT_SUPPORTED
+         fprintf(stderr, "incorrect gamma=(%d/100000)\n",
+            (int)png_ptr->int_gamma);
+#  else
+#    ifdef PNG_FLOATING_POINT_SUPPORTED
+         fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);
+#    endif
+#  endif
+#endif
+      }
+   }
+#endif /* PNG_READ_gAMA_SUPPORTED */
+
+#ifdef PNG_READ_cHRM_SUPPORTED
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+      if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270,  1000) ||
+          PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900,  1000) ||
+          PNG_OUT_OF_RANGE(info_ptr->int_x_red,   64000L, 1000) ||
+          PNG_OUT_OF_RANGE(info_ptr->int_y_red,   33000,  1000) ||
+          PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000,  1000) ||
+          PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) ||
+          PNG_OUT_OF_RANGE(info_ptr->int_x_blue,  15000,  1000) ||
+          PNG_OUT_OF_RANGE(info_ptr->int_y_blue,   6000,  1000))
+         {
+            png_warning(png_ptr,
+              "Ignoring incorrect cHRM value when sRGB is also present");
+         }
+#endif /* PNG_FIXED_POINT_SUPPORTED */
+#endif /* PNG_READ_cHRM_SUPPORTED */
+
+   png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
+}
+#endif /* PNG_READ_sRGB_SUPPORTED */
+
+#ifdef PNG_READ_iCCP_SUPPORTED
+void /* PRIVATE */
+png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+/* Note: this does not properly handle chunks that are > 64K under DOS */
+{
+   png_byte compression_type;
+   png_bytep pC;
+   png_charp profile;
+   png_uint_32 skip = 0;
+   png_uint_32 profile_size, profile_length;
+   png_size_t slength, prefix_length, data_length;
+
+   png_debug(1, "in png_handle_iCCP");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before iCCP");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid iCCP after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (png_ptr->mode & PNG_HAVE_PLTE)
+      /* Should be an error, but we can cope with it */
+      png_warning(png_ptr, "Out of place iCCP chunk");
+
+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))
+   {
+      png_warning(png_ptr, "Duplicate iCCP chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (length > (png_uint_32)65535L)
+   {
+      png_warning(png_ptr, "iCCP chunk too large to fit in memory");
+      skip = length - (png_uint_32)65535L;
+      length = (png_uint_32)65535L;
+   }
+#endif
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+   if (png_crc_finish(png_ptr, skip))
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   png_ptr->chunkdata[slength] = 0x00;
+
+   for (profile = png_ptr->chunkdata; *profile; profile++)
+      /* Empty loop to find end of name */ ;
+
+   ++profile;
+
+   /* There should be at least one zero (the compression type byte)
+    * following the separator, and we should be on it
+    */
+   if ( profile >= png_ptr->chunkdata + slength - 1)
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      png_warning(png_ptr, "Malformed iCCP chunk");
+      return;
+   }
+
+   /* Compression_type should always be zero */
+   compression_type = *profile++;
+   if (compression_type)
+   {
+      png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
+      compression_type = 0x00;  /* Reset it to zero (libpng-1.0.6 through 1.0.8
+                                 wrote nonzero) */
+   }
+
+   prefix_length = profile - png_ptr->chunkdata;
+   png_decompress_chunk(png_ptr, compression_type,
+     slength, prefix_length, &data_length);
+
+   profile_length = data_length - prefix_length;
+
+   if ( prefix_length > data_length || profile_length < 4)
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      png_warning(png_ptr, "Profile size field missing from iCCP chunk");
+      return;
+   }
+
+   /* Check the profile_size recorded in the first 32 bits of the ICC profile */
+   pC = (png_bytep)(png_ptr->chunkdata + prefix_length);
+   profile_size = ((*(pC    ))<<24) |
+                  ((*(pC + 1))<<16) |
+                  ((*(pC + 2))<< 8) |
+                  ((*(pC + 3))    );
+
+   if (profile_size < profile_length)
+      profile_length = profile_size;
+
+   if (profile_size > profile_length)
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      png_warning(png_ptr, "Ignoring truncated iCCP profile");
+      return;
+   }
+
+   png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,
+     compression_type, png_ptr->chunkdata + prefix_length, profile_length);
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = NULL;
+}
+#endif /* PNG_READ_iCCP_SUPPORTED */
+
+#ifdef PNG_READ_sPLT_SUPPORTED
+void /* PRIVATE */
+png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+/* Note: this does not properly handle chunks that are > 64K under DOS */
+{
+   png_bytep entry_start;
+   png_sPLT_t new_palette;
+#ifdef PNG_POINTER_INDEXING_SUPPORTED
+   png_sPLT_entryp pp;
+#endif
+   int data_length, entry_size, i;
+   png_uint_32 skip = 0;
+   png_size_t slength;
+
+   png_debug(1, "in png_handle_sPLT");
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+
+   if (png_ptr->user_chunk_cache_max != 0)
+   {
+      if (png_ptr->user_chunk_cache_max == 1)
+      {
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      if (--png_ptr->user_chunk_cache_max == 1)
+      {
+         png_warning(png_ptr, "No space in chunk cache for sPLT");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+   }
+#endif
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before sPLT");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid sPLT after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (length > (png_uint_32)65535L)
+   {
+      png_warning(png_ptr, "sPLT chunk too large to fit in memory");
+      skip = length - (png_uint_32)65535L;
+      length = (png_uint_32)65535L;
+   }
+#endif
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+   if (png_crc_finish(png_ptr, skip))
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   png_ptr->chunkdata[slength] = 0x00;
+
+   for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++)
+      /* Empty loop to find end of name */ ;
+   ++entry_start;
+
+   /* A sample depth should follow the separator, and we should be on it  */
+   if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      png_warning(png_ptr, "malformed sPLT chunk");
+      return;
+   }
+
+   new_palette.depth = *entry_start++;
+   entry_size = (new_palette.depth == 8 ? 6 : 10);
+   data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));
+
+   /* Integrity-check the data length */
+   if (data_length % entry_size)
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      png_warning(png_ptr, "sPLT chunk has bad length");
+      return;
+   }
+
+   new_palette.nentries = (png_int_32) ( data_length / entry_size);
+   if ((png_uint_32) new_palette.nentries >
+       (png_uint_32) (PNG_SIZE_MAX / png_sizeof(png_sPLT_entry)))
+   {
+       png_warning(png_ptr, "sPLT chunk too long");
+       return;
+   }
+   new_palette.entries = (png_sPLT_entryp)png_malloc_warn(
+       png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
+   if (new_palette.entries == NULL)
+   {
+       png_warning(png_ptr, "sPLT chunk requires too much memory");
+       return;
+   }
+
+#ifdef PNG_POINTER_INDEXING_SUPPORTED
+   for (i = 0; i < new_palette.nentries; i++)
+   {
+      pp = new_palette.entries + i;
+
+      if (new_palette.depth == 8)
+      {
+          pp->red = *entry_start++;
+          pp->green = *entry_start++;
+          pp->blue = *entry_start++;
+          pp->alpha = *entry_start++;
+      }
+      else
+      {
+          pp->red   = png_get_uint_16(entry_start); entry_start += 2;
+          pp->green = png_get_uint_16(entry_start); entry_start += 2;
+          pp->blue  = png_get_uint_16(entry_start); entry_start += 2;
+          pp->alpha = png_get_uint_16(entry_start); entry_start += 2;
+      }
+      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;
+   }
+#else
+   pp = new_palette.entries;
+   for (i = 0; i < new_palette.nentries; i++)
+   {
+
+      if (new_palette.depth == 8)
+      {
+          pp[i].red   = *entry_start++;
+          pp[i].green = *entry_start++;
+          pp[i].blue  = *entry_start++;
+          pp[i].alpha = *entry_start++;
+      }
+      else
+      {
+          pp[i].red   = png_get_uint_16(entry_start); entry_start += 2;
+          pp[i].green = png_get_uint_16(entry_start); entry_start += 2;
+          pp[i].blue  = png_get_uint_16(entry_start); entry_start += 2;
+          pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;
+      }
+      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;
+   }
+#endif
+
+   /* Discard all chunk data except the name and stash that */
+   new_palette.name = png_ptr->chunkdata;
+
+   png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = NULL;
+   png_free(png_ptr, new_palette.entries);
+}
+#endif /* PNG_READ_sPLT_SUPPORTED */
+
+#ifdef PNG_READ_tRNS_SUPPORTED
+void /* PRIVATE */
+png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_byte readbuf[PNG_MAX_PALETTE_LENGTH];
+
+   png_debug(1, "in png_handle_tRNS");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before tRNS");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid tRNS after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
+   {
+      png_warning(png_ptr, "Duplicate tRNS chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+   {
+      png_byte buf[2];
+
+      if (length != 2)
+      {
+         png_warning(png_ptr, "Incorrect tRNS chunk length");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+
+      png_crc_read(png_ptr, buf, 2);
+      png_ptr->num_trans = 1;
+      png_ptr->trans_color.gray = png_get_uint_16(buf);
+   }
+   else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+   {
+      png_byte buf[6];
+
+      if (length != 6)
+      {
+         png_warning(png_ptr, "Incorrect tRNS chunk length");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      png_crc_read(png_ptr, buf, (png_size_t)length);
+      png_ptr->num_trans = 1;
+      png_ptr->trans_color.red = png_get_uint_16(buf);
+      png_ptr->trans_color.green = png_get_uint_16(buf + 2);
+      png_ptr->trans_color.blue = png_get_uint_16(buf + 4);
+   }
+   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (!(png_ptr->mode & PNG_HAVE_PLTE))
+      {
+         /* Should be an error, but we can cope with it. */
+         png_warning(png_ptr, "Missing PLTE before tRNS");
+      }
+      if (length > (png_uint_32)png_ptr->num_palette ||
+          length > PNG_MAX_PALETTE_LENGTH)
+      {
+         png_warning(png_ptr, "Incorrect tRNS chunk length");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      if (length == 0)
+      {
+         png_warning(png_ptr, "Zero length tRNS chunk");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      png_crc_read(png_ptr, readbuf, (png_size_t)length);
+      png_ptr->num_trans = (png_uint_16)length;
+   }
+   else
+   {
+      png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (png_crc_finish(png_ptr, 0))
+   {
+      png_ptr->num_trans = 0;
+      return;
+   }
+
+   png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
+      &(png_ptr->trans_color));
+}
+#endif
+
+#ifdef PNG_READ_bKGD_SUPPORTED
+void /* PRIVATE */
+png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_size_t truelen;
+   png_byte buf[6];
+
+   png_debug(1, "in png_handle_bKGD");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before bKGD");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid bKGD after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+            !(png_ptr->mode & PNG_HAVE_PLTE))
+   {
+      png_warning(png_ptr, "Missing PLTE before bKGD");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))
+   {
+      png_warning(png_ptr, "Duplicate bKGD chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      truelen = 1;
+   else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
+      truelen = 6;
+   else
+      truelen = 2;
+
+   if (length != truelen)
+   {
+      png_warning(png_ptr, "Incorrect bKGD chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, truelen);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   /* We convert the index value into RGB components so that we can allow
+    * arbitrary RGB values for background when we have transparency, and
+    * so it is easy to determine the RGB values of the background color
+    * from the info_ptr struct. */
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      png_ptr->background.index = buf[0];
+      if (info_ptr && info_ptr->num_palette)
+      {
+          if (buf[0] >= info_ptr->num_palette)
+          {
+             png_warning(png_ptr, "Incorrect bKGD chunk index value");
+             return;
+          }
+          png_ptr->background.red =
+             (png_uint_16)png_ptr->palette[buf[0]].red;
+          png_ptr->background.green =
+             (png_uint_16)png_ptr->palette[buf[0]].green;
+          png_ptr->background.blue =
+             (png_uint_16)png_ptr->palette[buf[0]].blue;
+      }
+   }
+   else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
+   {
+      png_ptr->background.red =
+      png_ptr->background.green =
+      png_ptr->background.blue =
+      png_ptr->background.gray = png_get_uint_16(buf);
+   }
+   else
+   {
+      png_ptr->background.red = png_get_uint_16(buf);
+      png_ptr->background.green = png_get_uint_16(buf + 2);
+      png_ptr->background.blue = png_get_uint_16(buf + 4);
+   }
+
+   png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));
+}
+#endif
+
+#ifdef PNG_READ_hIST_SUPPORTED
+void /* PRIVATE */
+png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   unsigned int num, i;
+   png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];
+
+   png_debug(1, "in png_handle_hIST");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before hIST");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid hIST after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (!(png_ptr->mode & PNG_HAVE_PLTE))
+   {
+      png_warning(png_ptr, "Missing PLTE before hIST");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))
+   {
+      png_warning(png_ptr, "Duplicate hIST chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   num = length / 2 ;
+   if (num != (unsigned int) png_ptr->num_palette || num >
+      (unsigned int) PNG_MAX_PALETTE_LENGTH)
+   {
+      png_warning(png_ptr, "Incorrect hIST chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   for (i = 0; i < num; i++)
+   {
+      png_byte buf[2];
+
+      png_crc_read(png_ptr, buf, 2);
+      readbuf[i] = png_get_uint_16(buf);
+   }
+
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   png_set_hIST(png_ptr, info_ptr, readbuf);
+}
+#endif
+
+#ifdef PNG_READ_pHYs_SUPPORTED
+void /* PRIVATE */
+png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_byte buf[9];
+   png_uint_32 res_x, res_y;
+   int unit_type;
+
+   png_debug(1, "in png_handle_pHYs");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before pHYs");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid pHYs after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
+   {
+      png_warning(png_ptr, "Duplicate pHYs chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (length != 9)
+   {
+      png_warning(png_ptr, "Incorrect pHYs chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, 9);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   res_x = png_get_uint_32(buf);
+   res_y = png_get_uint_32(buf + 4);
+   unit_type = buf[8];
+   png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
+}
+#endif
+
+#ifdef PNG_READ_oFFs_SUPPORTED
+void /* PRIVATE */
+png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_byte buf[9];
+   png_int_32 offset_x, offset_y;
+   int unit_type;
+
+   png_debug(1, "in png_handle_oFFs");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before oFFs");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid oFFs after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
+   {
+      png_warning(png_ptr, "Duplicate oFFs chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (length != 9)
+   {
+      png_warning(png_ptr, "Incorrect oFFs chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, 9);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   offset_x = png_get_int_32(buf);
+   offset_y = png_get_int_32(buf + 4);
+   unit_type = buf[8];
+   png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
+}
+#endif
+
+#ifdef PNG_READ_pCAL_SUPPORTED
+/* Read the pCAL chunk (described in the PNG Extensions document) */
+void /* PRIVATE */
+png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_int_32 X0, X1;
+   png_byte type, nparams;
+   png_charp buf, units, endptr;
+   png_charpp params;
+   png_size_t slength;
+   int i;
+
+   png_debug(1, "in png_handle_pCAL");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before pCAL");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid pCAL after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))
+   {
+      png_warning(png_ptr, "Duplicate pCAL chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)",
+      length + 1);
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+   if (png_ptr->chunkdata == NULL)
+     {
+       png_warning(png_ptr, "No memory for pCAL purpose");
+       return;
+     }
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+   if (png_crc_finish(png_ptr, 0))
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
+
+   png_debug(3, "Finding end of pCAL purpose string");
+   for (buf = png_ptr->chunkdata; *buf; buf++)
+      /* Empty loop */ ;
+
+   endptr = png_ptr->chunkdata + slength;
+
+   /* We need to have at least 12 bytes after the purpose string
+      in order to get the parameter information. */
+   if (endptr <= buf + 12)
+   {
+      png_warning(png_ptr, "Invalid pCAL data");
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   png_debug(3, "Reading pCAL X0, X1, type, nparams, and units");
+   X0 = png_get_int_32((png_bytep)buf+1);
+   X1 = png_get_int_32((png_bytep)buf+5);
+   type = buf[9];
+   nparams = buf[10];
+   units = buf + 11;
+
+   png_debug(3, "Checking pCAL equation type and number of parameters");
+   /* Check that we have the right number of parameters for known
+      equation types. */
+   if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||
+       (type == PNG_EQUATION_BASE_E && nparams != 3) ||
+       (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||
+       (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))
+   {
+      png_warning(png_ptr, "Invalid pCAL parameters for equation type");
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+   else if (type >= PNG_EQUATION_LAST)
+   {
+      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
+   }
+
+   for (buf = units; *buf; buf++)
+      /* Empty loop to move past the units string. */ ;
+
+   png_debug(3, "Allocating pCAL parameters array");
+   params = (png_charpp)png_malloc_warn(png_ptr,
+      (png_size_t)(nparams * png_sizeof(png_charp)));
+   if (params == NULL)
+     {
+       png_free(png_ptr, png_ptr->chunkdata);
+       png_ptr->chunkdata = NULL;
+       png_warning(png_ptr, "No memory for pCAL params");
+       return;
+     }
+
+   /* Get pointers to the start of each parameter string. */
+   for (i = 0; i < (int)nparams; i++)
+   {
+      buf++; /* Skip the null string terminator from previous parameter. */
+
+      png_debug1(3, "Reading pCAL parameter %d", i);
+      for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++)
+         /* Empty loop to move past each parameter string */ ;
+
+      /* Make sure we haven't run out of data yet */
+      if (buf > endptr)
+      {
+         png_warning(png_ptr, "Invalid pCAL data");
+         png_free(png_ptr, png_ptr->chunkdata);
+         png_ptr->chunkdata = NULL;
+         png_free(png_ptr, params);
+         return;
+      }
+   }
+
+   png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,
+      units, params);
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = NULL;
+   png_free(png_ptr, params);
+}
+#endif
+
+#ifdef PNG_READ_sCAL_SUPPORTED
+/* Read the sCAL chunk */
+void /* PRIVATE */
+png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_charp ep;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   double width, height;
+   png_charp vp;
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   png_charp swidth, sheight;
+#endif
+#endif
+   png_size_t slength;
+
+   png_debug(1, "in png_handle_sCAL");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before sCAL");
+   else if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      png_warning(png_ptr, "Invalid sCAL after IDAT");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))
+   {
+      png_warning(png_ptr, "Duplicate sCAL chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)",
+      length + 1);
+   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+   if (png_ptr->chunkdata == NULL)
+   {
+      png_warning(png_ptr, "Out of memory while processing sCAL chunk");
+      return;
+   }
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+   if (png_crc_finish(png_ptr, 0))
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
+
+   ep = png_ptr->chunkdata + 1;        /* Skip unit byte */
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   width = png_strtod(png_ptr, ep, &vp);
+   if (*vp)
+   {
+      png_warning(png_ptr, "malformed width string in sCAL chunk");
+      return;
+   }
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
+   if (swidth == NULL)
+   {
+      png_warning(png_ptr, "Out of memory while processing sCAL chunk width");
+      return;
+   }
+   png_memcpy(swidth, ep, png_strlen(ep));
+#endif
+#endif
+
+   for (ep = png_ptr->chunkdata; *ep; ep++)
+      /* Empty loop */ ;
+   ep++;
+
+   if (png_ptr->chunkdata + slength < ep)
+   {
+      png_warning(png_ptr, "Truncated sCAL chunk");
+#if defined(PNG_FIXED_POINT_SUPPORTED) && \
+    !defined(PNG_FLOATING_POINT_SUPPORTED)
+      png_free(png_ptr, swidth);
+#endif
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   height = png_strtod(png_ptr, ep, &vp);
+   if (*vp)
+   {
+      png_warning(png_ptr, "malformed height string in sCAL chunk");
+      return;
+   }
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);
+   if (sheight == NULL)
+   {
+      png_warning(png_ptr, "Out of memory while processing sCAL chunk height");
+      return;
+   }
+   png_memcpy(sheight, ep, png_strlen(ep));
+#endif
+#endif
+
+   if (png_ptr->chunkdata + slength < ep
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+      || width <= 0. || height <= 0.
+#endif
+      )
+   {
+      png_warning(png_ptr, "Invalid sCAL data");
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
+      png_free(png_ptr, swidth);
+      png_free(png_ptr, sheight);
+#endif
+      return;
+   }
+
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);
+#endif
+#endif
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = NULL;
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
+   png_free(png_ptr, swidth);
+   png_free(png_ptr, sheight);
+#endif
+}
+#endif
+
+#ifdef PNG_READ_tIME_SUPPORTED
+void /* PRIVATE */
+png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_byte buf[7];
+   png_time mod_time;
+
+   png_debug(1, "in png_handle_tIME");
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Out of place tIME chunk");
+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))
+   {
+      png_warning(png_ptr, "Duplicate tIME chunk");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   if (png_ptr->mode & PNG_HAVE_IDAT)
+      png_ptr->mode |= PNG_AFTER_IDAT;
+
+   if (length != 7)
+   {
+      png_warning(png_ptr, "Incorrect tIME chunk length");
+      png_crc_finish(png_ptr, length);
+      return;
+   }
+
+   png_crc_read(png_ptr, buf, 7);
+   if (png_crc_finish(png_ptr, 0))
+      return;
+
+   mod_time.second = buf[6];
+   mod_time.minute = buf[5];
+   mod_time.hour = buf[4];
+   mod_time.day = buf[3];
+   mod_time.month = buf[2];
+   mod_time.year = png_get_uint_16(buf);
+
+   png_set_tIME(png_ptr, info_ptr, &mod_time);
+}
+#endif
+
+#ifdef PNG_READ_tEXt_SUPPORTED
+/* Note: this does not properly handle chunks that are > 64K under DOS */
+void /* PRIVATE */
+png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_textp text_ptr;
+   png_charp key;
+   png_charp text;
+   png_uint_32 skip = 0;
+   png_size_t slength;
+   int ret;
+
+   png_debug(1, "in png_handle_tEXt");
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   if (png_ptr->user_chunk_cache_max != 0)
+   {
+      if (png_ptr->user_chunk_cache_max == 1)
+      {
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      if (--png_ptr->user_chunk_cache_max == 1)
+      {
+         png_warning(png_ptr, "No space in chunk cache for tEXt");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+   }
+#endif
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before tEXt");
+
+   if (png_ptr->mode & PNG_HAVE_IDAT)
+      png_ptr->mode |= PNG_AFTER_IDAT;
+
+#ifdef PNG_MAX_MALLOC_64K
+   if (length > (png_uint_32)65535L)
+   {
+      png_warning(png_ptr, "tEXt chunk too large to fit in memory");
+      skip = length - (png_uint_32)65535L;
+      length = (png_uint_32)65535L;
+   }
+#endif
+
+   png_free(png_ptr, png_ptr->chunkdata);
+
+   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+   if (png_ptr->chunkdata == NULL)
+   {
+     png_warning(png_ptr, "No memory to process text chunk");
+     return;
+   }
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+
+   if (png_crc_finish(png_ptr, skip))
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   key = png_ptr->chunkdata;
+
+   key[slength] = 0x00;
+
+   for (text = key; *text; text++)
+      /* Empty loop to find end of key */ ;
+
+   if (text != key + slength)
+      text++;
+
+   text_ptr = (png_textp)png_malloc_warn(png_ptr,
+      png_sizeof(png_text));
+   if (text_ptr == NULL)
+   {
+     png_warning(png_ptr, "Not enough memory to process text chunk");
+     png_free(png_ptr, png_ptr->chunkdata);
+     png_ptr->chunkdata = NULL;
+     return;
+   }
+   text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
+   text_ptr->key = key;
+#ifdef PNG_iTXt_SUPPORTED
+   text_ptr->lang = NULL;
+   text_ptr->lang_key = NULL;
+   text_ptr->itxt_length = 0;
+#endif
+   text_ptr->text = text;
+   text_ptr->text_length = png_strlen(text);
+
+   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = NULL;
+   png_free(png_ptr, text_ptr);
+   if (ret)
+     png_warning(png_ptr, "Insufficient memory to process text chunk");
+}
+#endif
+
+#ifdef PNG_READ_zTXt_SUPPORTED
+/* Note: this does not correctly handle chunks that are > 64K under DOS */
+void /* PRIVATE */
+png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_textp text_ptr;
+   png_charp text;
+   int comp_type;
+   int ret;
+   png_size_t slength, prefix_len, data_len;
+
+   png_debug(1, "in png_handle_zTXt");
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   if (png_ptr->user_chunk_cache_max != 0)
+   {
+      if (png_ptr->user_chunk_cache_max == 1)
+      {
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      if (--png_ptr->user_chunk_cache_max == 1)
+      {
+         png_warning(png_ptr, "No space in chunk cache for zTXt");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+   }
+#endif
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before zTXt");
+
+   if (png_ptr->mode & PNG_HAVE_IDAT)
+      png_ptr->mode |= PNG_AFTER_IDAT;
+
+#ifdef PNG_MAX_MALLOC_64K
+   /* We will no doubt have problems with chunks even half this size, but
+      there is no hard and fast rule to tell us where to stop. */
+   if (length > (png_uint_32)65535L)
+   {
+     png_warning(png_ptr, "zTXt chunk too large to fit in memory");
+     png_crc_finish(png_ptr, length);
+     return;
+   }
+#endif
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+   if (png_ptr->chunkdata == NULL)
+   {
+     png_warning(png_ptr, "Out of memory processing zTXt chunk");
+     return;
+   }
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+   if (png_crc_finish(png_ptr, 0))
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   png_ptr->chunkdata[slength] = 0x00;
+
+   for (text = png_ptr->chunkdata; *text; text++)
+      /* Empty loop */ ;
+
+   /* zTXt must have some text after the chunkdataword */
+   if (text >= png_ptr->chunkdata + slength - 2)
+   {
+      png_warning(png_ptr, "Truncated zTXt chunk");
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+   else
+   {
+       comp_type = *(++text);
+       if (comp_type != PNG_TEXT_COMPRESSION_zTXt)
+       {
+          png_warning(png_ptr, "Unknown compression type in zTXt chunk");
+          comp_type = PNG_TEXT_COMPRESSION_zTXt;
+       }
+       text++;        /* Skip the compression_method byte */
+   }
+   prefix_len = text - png_ptr->chunkdata;
+
+   png_decompress_chunk(png_ptr, comp_type,
+     (png_size_t)length, prefix_len, &data_len);
+
+   text_ptr = (png_textp)png_malloc_warn(png_ptr,
+      png_sizeof(png_text));
+   if (text_ptr == NULL)
+   {
+     png_warning(png_ptr, "Not enough memory to process zTXt chunk");
+     png_free(png_ptr, png_ptr->chunkdata);
+     png_ptr->chunkdata = NULL;
+     return;
+   }
+   text_ptr->compression = comp_type;
+   text_ptr->key = png_ptr->chunkdata;
+#ifdef PNG_iTXt_SUPPORTED
+   text_ptr->lang = NULL;
+   text_ptr->lang_key = NULL;
+   text_ptr->itxt_length = 0;
+#endif
+   text_ptr->text = png_ptr->chunkdata + prefix_len;
+   text_ptr->text_length = data_len;
+
+   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+   png_free(png_ptr, text_ptr);
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = NULL;
+   if (ret)
+     png_error(png_ptr, "Insufficient memory to store zTXt chunk");
+}
+#endif
+
+#ifdef PNG_READ_iTXt_SUPPORTED
+/* Note: this does not correctly handle chunks that are > 64K under DOS */
+void /* PRIVATE */
+png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_textp text_ptr;
+   png_charp key, lang, text, lang_key;
+   int comp_flag;
+   int comp_type = 0;
+   int ret;
+   png_size_t slength, prefix_len, data_len;
+
+   png_debug(1, "in png_handle_iTXt");
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   if (png_ptr->user_chunk_cache_max != 0)
+   {
+      if (png_ptr->user_chunk_cache_max == 1)
+      {
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      if (--png_ptr->user_chunk_cache_max == 1)
+      {
+         png_warning(png_ptr, "No space in chunk cache for iTXt");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+   }
+#endif
+
+   if (!(png_ptr->mode & PNG_HAVE_IHDR))
+      png_error(png_ptr, "Missing IHDR before iTXt");
+
+   if (png_ptr->mode & PNG_HAVE_IDAT)
+      png_ptr->mode |= PNG_AFTER_IDAT;
+
+#ifdef PNG_MAX_MALLOC_64K
+   /* We will no doubt have problems with chunks even half this size, but
+      there is no hard and fast rule to tell us where to stop. */
+   if (length > (png_uint_32)65535L)
+   {
+     png_warning(png_ptr, "iTXt chunk too large to fit in memory");
+     png_crc_finish(png_ptr, length);
+     return;
+   }
+#endif
+
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+   if (png_ptr->chunkdata == NULL)
+   {
+     png_warning(png_ptr, "No memory to process iTXt chunk");
+     return;
+   }
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+   if (png_crc_finish(png_ptr, 0))
+   {
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   png_ptr->chunkdata[slength] = 0x00;
+
+   for (lang = png_ptr->chunkdata; *lang; lang++)
+      /* Empty loop */ ;
+   lang++;        /* Skip NUL separator */
+
+   /* iTXt must have a language tag (possibly empty), two compression bytes,
+    * translated keyword (possibly empty), and possibly some text after the
+    * keyword
+    */
+
+   if (lang >= png_ptr->chunkdata + slength - 3)
+   {
+      png_warning(png_ptr, "Truncated iTXt chunk");
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+   else
+   {
+       comp_flag = *lang++;
+       comp_type = *lang++;
+   }
+
+   for (lang_key = lang; *lang_key; lang_key++)
+      /* Empty loop */ ;
+   lang_key++;        /* Skip NUL separator */
+
+   if (lang_key >= png_ptr->chunkdata + slength)
+   {
+      png_warning(png_ptr, "Truncated iTXt chunk");
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   for (text = lang_key; *text; text++)
+      /* Empty loop */ ;
+   text++;        /* Skip NUL separator */
+   if (text >= png_ptr->chunkdata + slength)
+   {
+      png_warning(png_ptr, "Malformed iTXt chunk");
+      png_free(png_ptr, png_ptr->chunkdata);
+      png_ptr->chunkdata = NULL;
+      return;
+   }
+
+   prefix_len = text - png_ptr->chunkdata;
+
+   key=png_ptr->chunkdata;
+   if (comp_flag)
+       png_decompress_chunk(png_ptr, comp_type,
+         (size_t)length, prefix_len, &data_len);
+   else
+       data_len = png_strlen(png_ptr->chunkdata + prefix_len);
+   text_ptr = (png_textp)png_malloc_warn(png_ptr,
+      png_sizeof(png_text));
+   if (text_ptr == NULL)
+   {
+     png_warning(png_ptr, "Not enough memory to process iTXt chunk");
+     png_free(png_ptr, png_ptr->chunkdata);
+     png_ptr->chunkdata = NULL;
+     return;
+   }
+   text_ptr->compression = (int)comp_flag + 1;
+   text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);
+   text_ptr->lang = png_ptr->chunkdata + (lang - key);
+   text_ptr->itxt_length = data_len;
+   text_ptr->text_length = 0;
+   text_ptr->key = png_ptr->chunkdata;
+   text_ptr->text = png_ptr->chunkdata + prefix_len;
+
+   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+
+   png_free(png_ptr, text_ptr);
+   png_free(png_ptr, png_ptr->chunkdata);
+   png_ptr->chunkdata = NULL;
+   if (ret)
+     png_error(png_ptr, "Insufficient memory to store iTXt chunk");
+}
+#endif
+
+/* This function is called when we haven't found a handler for a
+   chunk.  If there isn't a problem with the chunk itself (ie bad
+   chunk name, CRC, or a critical chunk), the chunk is silently ignored
+   -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which
+   case it will be saved away to be written out later. */
+void /* PRIVATE */
+png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+{
+   png_uint_32 skip = 0;
+
+   png_debug(1, "in png_handle_unknown");
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   if (png_ptr->user_chunk_cache_max != 0)
+   {
+      if (png_ptr->user_chunk_cache_max == 1)
+      {
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+      if (--png_ptr->user_chunk_cache_max == 1)
+      {
+         png_warning(png_ptr, "No space in chunk cache for unknown chunk");
+         png_crc_finish(png_ptr, length);
+         return;
+      }
+   }
+#endif
+
+   if (png_ptr->mode & PNG_HAVE_IDAT)
+   {
+      PNG_IDAT;
+      if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))  /* Not an IDAT */
+         png_ptr->mode |= PNG_AFTER_IDAT;
+   }
+
+   if (!(png_ptr->chunk_name[0] & 0x20))
+   {
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+      if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+           PNG_HANDLE_CHUNK_ALWAYS
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+           && png_ptr->read_user_chunk_fn == NULL
+#endif
+        )
+#endif
+          png_chunk_error(png_ptr, "unknown critical chunk");
+   }
+
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+   if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+       || (png_ptr->read_user_chunk_fn != NULL)
+#endif
+        )
+   {
+#ifdef PNG_MAX_MALLOC_64K
+       if (length > (png_uint_32)65535L)
+       {
+           png_warning(png_ptr, "unknown chunk too large to fit in memory");
+           skip = length - (png_uint_32)65535L;
+           length = (png_uint_32)65535L;
+       }
+#endif
+       png_memcpy((png_charp)png_ptr->unknown_chunk.name,
+                  (png_charp)png_ptr->chunk_name,
+                  png_sizeof(png_ptr->unknown_chunk.name));
+       png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1] = '\0';
+       png_ptr->unknown_chunk.size = (png_size_t)length;
+       if (length == 0)
+         png_ptr->unknown_chunk.data = NULL;
+       else
+       {
+         png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
+         png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
+       }
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+       if (png_ptr->read_user_chunk_fn != NULL)
+       {
+          /* Callback to user unknown chunk handler */
+          int ret;
+          ret = (*(png_ptr->read_user_chunk_fn))
+            (png_ptr, &png_ptr->unknown_chunk);
+          if (ret < 0)
+             png_chunk_error(png_ptr, "error in user chunk");
+          if (ret == 0)
+          {
+             if (!(png_ptr->chunk_name[0] & 0x20))
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+                if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+                     PNG_HANDLE_CHUNK_ALWAYS)
+#endif
+                   png_chunk_error(png_ptr, "unknown critical chunk");
+             png_set_unknown_chunks(png_ptr, info_ptr,
+               &png_ptr->unknown_chunk, 1);
+          }
+       }
+       else
+#endif
+       png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
+       png_free(png_ptr, png_ptr->unknown_chunk.data);
+       png_ptr->unknown_chunk.data = NULL;
+   }
+   else
+#endif
+      skip = length;
+
+   png_crc_finish(png_ptr, skip);
+
+#ifndef PNG_READ_USER_CHUNKS_SUPPORTED
+   info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */
+#endif
+}
+
+/* This function is called to verify that a chunk name is valid.
+   This function can't have the "critical chunk check" incorporated
+   into it, since in the future we will need to be able to call user
+   functions to handle unknown critical chunks after we check that
+   the chunk name itself is valid. */
+
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
+
+void /* PRIVATE */
+png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
+{
+   png_debug(1, "in png_check_chunk_name");
+   if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||
+       isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))
+   {
+      png_chunk_error(png_ptr, "invalid chunk type");
+   }
+}
+
+/* Combines the row recently read in with the existing pixels in the
+   row.  This routine takes care of alpha and transparency if requested.
+   This routine also handles the two methods of progressive display
+   of interlaced images, depending on the mask value.
+   The mask value describes which pixels are to be combined with
+   the row.  The pattern always repeats every 8 pixels, so just 8
+   bits are needed.  A one indicates the pixel is to be combined,
+   a zero indicates the pixel is to be skipped.  This is in addition
+   to any alpha or transparency value associated with the pixel.  If
+   you want all pixels to be combined, pass 0xff (255) in mask.  */
+
+void /* PRIVATE */
+png_combine_row(png_structp png_ptr, png_bytep row, int mask)
+{
+   png_debug(1, "in png_combine_row");
+   if (mask == 0xff)
+   {
+      png_memcpy(row, png_ptr->row_buf + 1,
+         PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
+   }
+   else
+   {
+      switch (png_ptr->row_info.pixel_depth)
+      {
+         case 1:
+         {
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
+            int s_inc, s_start, s_end;
+            int m = 0x80;
+            int shift;
+            png_uint_32 i;
+            png_uint_32 row_width = png_ptr->width;
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+            if (png_ptr->transformations & PNG_PACKSWAP)
+            {
+                s_start = 0;
+                s_end = 7;
+                s_inc = 1;
+            }
+            else
+#endif
+            {
+                s_start = 7;
+                s_end = 0;
+                s_inc = -1;
+            }
+
+            shift = s_start;
+
+            for (i = 0; i < row_width; i++)
+            {
+               if (m & mask)
+               {
+                  int value;
+
+                  value = (*sp >> shift) & 0x01;
+                  *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
+                  *dp |= (png_byte)(value << shift);
+               }
+
+               if (shift == s_end)
+               {
+                  shift = s_start;
+                  sp++;
+                  dp++;
+               }
+               else
+                  shift += s_inc;
+
+               if (m == 1)
+                  m = 0x80;
+               else
+                  m >>= 1;
+            }
+            break;
+         }
+         case 2:
+         {
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
+            int s_start, s_end, s_inc;
+            int m = 0x80;
+            int shift;
+            png_uint_32 i;
+            png_uint_32 row_width = png_ptr->width;
+            int value;
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+            if (png_ptr->transformations & PNG_PACKSWAP)
+            {
+               s_start = 0;
+               s_end = 6;
+               s_inc = 2;
+            }
+            else
+#endif
+            {
+               s_start = 6;
+               s_end = 0;
+               s_inc = -2;
+            }
+
+            shift = s_start;
+
+            for (i = 0; i < row_width; i++)
+            {
+               if (m & mask)
+               {
+                  value = (*sp >> shift) & 0x03;
+                  *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+                  *dp |= (png_byte)(value << shift);
+               }
+
+               if (shift == s_end)
+               {
+                  shift = s_start;
+                  sp++;
+                  dp++;
+               }
+               else
+                  shift += s_inc;
+               if (m == 1)
+                  m = 0x80;
+               else
+                  m >>= 1;
+            }
+            break;
+         }
+         case 4:
+         {
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
+            int s_start, s_end, s_inc;
+            int m = 0x80;
+            int shift;
+            png_uint_32 i;
+            png_uint_32 row_width = png_ptr->width;
+            int value;
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+            if (png_ptr->transformations & PNG_PACKSWAP)
+            {
+               s_start = 0;
+               s_end = 4;
+               s_inc = 4;
+            }
+            else
+#endif
+            {
+               s_start = 4;
+               s_end = 0;
+               s_inc = -4;
+            }
+            shift = s_start;
+
+            for (i = 0; i < row_width; i++)
+            {
+               if (m & mask)
+               {
+                  value = (*sp >> shift) & 0xf;
+                  *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+                  *dp |= (png_byte)(value << shift);
+               }
+
+               if (shift == s_end)
+               {
+                  shift = s_start;
+                  sp++;
+                  dp++;
+               }
+               else
+                  shift += s_inc;
+               if (m == 1)
+                  m = 0x80;
+               else
+                  m >>= 1;
+            }
+            break;
+         }
+         default:
+         {
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
+            png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
+            png_uint_32 i;
+            png_uint_32 row_width = png_ptr->width;
+            png_byte m = 0x80;
+
+
+            for (i = 0; i < row_width; i++)
+            {
+               if (m & mask)
+               {
+                  png_memcpy(dp, sp, pixel_bytes);
+               }
+
+               sp += pixel_bytes;
+               dp += pixel_bytes;
+
+               if (m == 1)
+                  m = 0x80;
+               else
+                  m >>= 1;
+            }
+            break;
+         }
+      }
+   }
+}
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+/* OLD pre-1.0.9 interface:
+void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
+   png_uint_32 transformations)
+ */
+void /* PRIVATE */
+png_do_read_interlace(png_structp png_ptr)
+{
+   png_row_infop row_info = &(png_ptr->row_info);
+   png_bytep row = png_ptr->row_buf + 1;
+   int pass = png_ptr->pass;
+   png_uint_32 transformations = png_ptr->transformations;
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+   /* Offset to next interlace block */
+   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+   png_debug(1, "in png_do_read_interlace");
+   if (row != NULL && row_info != NULL)
+   {
+      png_uint_32 final_width;
+
+      final_width = row_info->width * png_pass_inc[pass];
+
+      switch (row_info->pixel_depth)
+      {
+         case 1:
+         {
+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);
+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);
+            int sshift, dshift;
+            int s_start, s_end, s_inc;
+            int jstop = png_pass_inc[pass];
+            png_byte v;
+            png_uint_32 i;
+            int j;
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+            if (transformations & PNG_PACKSWAP)
+            {
+                sshift = (int)((row_info->width + 7) & 0x07);
+                dshift = (int)((final_width + 7) & 0x07);
+                s_start = 7;
+                s_end = 0;
+                s_inc = -1;
+            }
+            else
+#endif
+            {
+                sshift = 7 - (int)((row_info->width + 7) & 0x07);
+                dshift = 7 - (int)((final_width + 7) & 0x07);
+                s_start = 0;
+                s_end = 7;
+                s_inc = 1;
+            }
+
+            for (i = 0; i < row_info->width; i++)
+            {
+               v = (png_byte)((*sp >> sshift) & 0x01);
+               for (j = 0; j < jstop; j++)
+               {
+                  *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
+                  *dp |= (png_byte)(v << dshift);
+                  if (dshift == s_end)
+                  {
+                     dshift = s_start;
+                     dp--;
+                  }
+                  else
+                     dshift += s_inc;
+               }
+               if (sshift == s_end)
+               {
+                  sshift = s_start;
+                  sp--;
+               }
+               else
+                  sshift += s_inc;
+            }
+            break;
+         }
+         case 2:
+         {
+            png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);
+            png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);
+            int sshift, dshift;
+            int s_start, s_end, s_inc;
+            int jstop = png_pass_inc[pass];
+            png_uint_32 i;
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+            if (transformations & PNG_PACKSWAP)
+            {
+               sshift = (int)(((row_info->width + 3) & 0x03) << 1);
+               dshift = (int)(((final_width + 3) & 0x03) << 1);
+               s_start = 6;
+               s_end = 0;
+               s_inc = -2;
+            }
+            else
+#endif
+            {
+               sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);
+               dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);
+               s_start = 0;
+               s_end = 6;
+               s_inc = 2;
+            }
+
+            for (i = 0; i < row_info->width; i++)
+            {
+               png_byte v;
+               int j;
+
+               v = (png_byte)((*sp >> sshift) & 0x03);
+               for (j = 0; j < jstop; j++)
+               {
+                  *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
+                  *dp |= (png_byte)(v << dshift);
+                  if (dshift == s_end)
+                  {
+                     dshift = s_start;
+                     dp--;
+                  }
+                  else
+                     dshift += s_inc;
+               }
+               if (sshift == s_end)
+               {
+                  sshift = s_start;
+                  sp--;
+               }
+               else
+                  sshift += s_inc;
+            }
+            break;
+         }
+         case 4:
+         {
+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);
+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);
+            int sshift, dshift;
+            int s_start, s_end, s_inc;
+            png_uint_32 i;
+            int jstop = png_pass_inc[pass];
+
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+            if (transformations & PNG_PACKSWAP)
+            {
+               sshift = (int)(((row_info->width + 1) & 0x01) << 2);
+               dshift = (int)(((final_width + 1) & 0x01) << 2);
+               s_start = 4;
+               s_end = 0;
+               s_inc = -4;
+            }
+            else
+#endif
+            {
+               sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);
+               dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);
+               s_start = 0;
+               s_end = 4;
+               s_inc = 4;
+            }
+
+            for (i = 0; i < row_info->width; i++)
+            {
+               png_byte v = (png_byte)((*sp >> sshift) & 0xf);
+               int j;
+
+               for (j = 0; j < jstop; j++)
+               {
+                  *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
+                  *dp |= (png_byte)(v << dshift);
+                  if (dshift == s_end)
+                  {
+                     dshift = s_start;
+                     dp--;
+                  }
+                  else
+                     dshift += s_inc;
+               }
+               if (sshift == s_end)
+               {
+                  sshift = s_start;
+                  sp--;
+               }
+               else
+                  sshift += s_inc;
+            }
+            break;
+         }
+         default:
+         {
+            png_size_t pixel_bytes = (row_info->pixel_depth >> 3);
+            png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;
+            png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
+
+            int jstop = png_pass_inc[pass];
+            png_uint_32 i;
+
+            for (i = 0; i < row_info->width; i++)
+            {
+               png_byte v[8];
+               int j;
+
+               png_memcpy(v, sp, pixel_bytes);
+               for (j = 0; j < jstop; j++)
+               {
+                  png_memcpy(dp, v, pixel_bytes);
+                  dp -= pixel_bytes;
+               }
+               sp -= pixel_bytes;
+            }
+            break;
+         }
+      }
+      row_info->width = final_width;
+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);
+   }
+#ifndef PNG_READ_PACKSWAP_SUPPORTED
+   transformations = transformations; /* Silence compiler warning */
+#endif
+}
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+
+void /* PRIVATE */
+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
+   png_bytep prev_row, int filter)
+{
+   png_debug(1, "in png_read_filter_row");
+   png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);
+   switch (filter)
+   {
+      case PNG_FILTER_VALUE_NONE:
+         break;
+      case PNG_FILTER_VALUE_SUB:
+      {
+         png_uint_32 i;
+         png_uint_32 istop = row_info->rowbytes;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
+         png_bytep rp = row + bpp;
+         png_bytep lp = row;
+
+         for (i = bpp; i < istop; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      case PNG_FILTER_VALUE_UP:
+      {
+         png_uint_32 i;
+         png_uint_32 istop = row_info->rowbytes;
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+
+         for (i = 0; i < istop; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      case PNG_FILTER_VALUE_AVG:
+      {
+         png_uint_32 i;
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+         png_bytep lp = row;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
+         png_uint_32 istop = row_info->rowbytes - bpp;
+
+         for (i = 0; i < bpp; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) +
+               ((int)(*pp++) / 2 )) & 0xff);
+            rp++;
+         }
+
+         for (i = 0; i < istop; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) +
+               (int)(*pp++ + *lp++) / 2 ) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      case PNG_FILTER_VALUE_PAETH:
+      {
+         png_uint_32 i;
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+         png_bytep lp = row;
+         png_bytep cp = prev_row;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
+         png_uint_32 istop=row_info->rowbytes - bpp;
+
+         for (i = 0; i < bpp; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+            rp++;
+         }
+
+         for (i = 0; i < istop; i++)   /* Use leftover rp,pp */
+         {
+            int a, b, c, pa, pb, pc, p;
+
+            a = *lp++;
+            b = *pp++;
+            c = *cp++;
+
+            p = b - c;
+            pc = a - c;
+
+#ifdef PNG_USE_ABS
+            pa = abs(p);
+            pb = abs(pc);
+            pc = abs(p + pc);
+#else
+            pa = p < 0 ? -p : p;
+            pb = pc < 0 ? -pc : pc;
+            pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+
+            /*
+               if (pa <= pb && pa <= pc)
+                  p = a;
+               else if (pb <= pc)
+                  p = b;
+               else
+                  p = c;
+             */
+
+            p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+
+            *rp = (png_byte)(((int)(*rp) + p) & 0xff);
+            rp++;
+         }
+         break;
+      }
+      default:
+         png_warning(png_ptr, "Ignoring bad adaptive filter type");
+         *row = 0;
+         break;
+   }
+}
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+void /* PRIVATE */
+png_read_finish_row(png_structp png_ptr)
+{
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+   /* Start of interlace block in the y direction */
+   PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+   /* Offset to next interlace block in the y direction */
+   PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+
+   png_debug(1, "in png_read_finish_row");
+   png_ptr->row_number++;
+   if (png_ptr->row_number < png_ptr->num_rows)
+      return;
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   if (png_ptr->interlaced)
+   {
+      png_ptr->row_number = 0;
+      png_memset(png_ptr->prev_row, 0,
+         png_ptr->rowbytes + 1);
+      do
+      {
+         png_ptr->pass++;
+         if (png_ptr->pass >= 7)
+            break;
+         png_ptr->iwidth = (png_ptr->width +
+            png_pass_inc[png_ptr->pass] - 1 -
+            png_pass_start[png_ptr->pass]) /
+            png_pass_inc[png_ptr->pass];
+
+         png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
+            png_ptr->iwidth) + 1;
+
+         if (!(png_ptr->transformations & PNG_INTERLACE))
+         {
+            png_ptr->num_rows = (png_ptr->height +
+               png_pass_yinc[png_ptr->pass] - 1 -
+               png_pass_ystart[png_ptr->pass]) /
+               png_pass_yinc[png_ptr->pass];
+            if (!(png_ptr->num_rows))
+               continue;
+         }
+         else  /* if (png_ptr->transformations & PNG_INTERLACE) */
+            break;
+      } while (png_ptr->iwidth == 0);
+
+      if (png_ptr->pass < 7)
+         return;
+   }
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+
+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+   {
+      PNG_IDAT;
+      char extra;
+      int ret;
+
+      png_ptr->zstream.next_out = (Byte *)&extra;
+      png_ptr->zstream.avail_out = (uInt)1;
+      for (;;)
+      {
+         if (!(png_ptr->zstream.avail_in))
+         {
+            while (!png_ptr->idat_size)
+            {
+               png_byte chunk_length[4];
+
+               png_crc_finish(png_ptr, 0);
+
+               png_read_data(png_ptr, chunk_length, 4);
+               png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);
+               png_reset_crc(png_ptr);
+               png_crc_read(png_ptr, png_ptr->chunk_name, 4);
+               if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+                  png_error(png_ptr, "Not enough image data");
+
+            }
+            png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
+            png_ptr->zstream.next_in = png_ptr->zbuf;
+            if (png_ptr->zbuf_size > png_ptr->idat_size)
+               png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
+            png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
+            png_ptr->idat_size -= png_ptr->zstream.avail_in;
+         }
+         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+         if (ret == Z_STREAM_END)
+         {
+            if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
+               png_ptr->idat_size)
+               png_warning(png_ptr, "Extra compressed data");
+            png_ptr->mode |= PNG_AFTER_IDAT;
+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+            break;
+         }
+         if (ret != Z_OK)
+            png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
+                      "Decompression Error");
+
+         if (!(png_ptr->zstream.avail_out))
+         {
+            png_warning(png_ptr, "Extra compressed data");
+            png_ptr->mode |= PNG_AFTER_IDAT;
+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+            break;
+         }
+
+      }
+      png_ptr->zstream.avail_out = 0;
+   }
+
+   if (png_ptr->idat_size || png_ptr->zstream.avail_in)
+      png_warning(png_ptr, "Extra compression data");
+
+   inflateReset(&png_ptr->zstream);
+
+   png_ptr->mode |= PNG_AFTER_IDAT;
+}
+#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+
+void /* PRIVATE */
+png_read_start_row(png_structp png_ptr)
+{
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+   /* Start of interlace block in the y direction */
+   PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+   /* Offset to next interlace block in the y direction */
+   PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif
+
+   int max_pixel_depth;
+   png_size_t row_bytes;
+
+   png_debug(1, "in png_read_start_row");
+   png_ptr->zstream.avail_in = 0;
+   png_init_read_transformations(png_ptr);
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   if (png_ptr->interlaced)
+   {
+      if (!(png_ptr->transformations & PNG_INTERLACE))
+         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
+            png_pass_ystart[0]) / png_pass_yinc[0];
+      else
+         png_ptr->num_rows = png_ptr->height;
+
+      png_ptr->iwidth = (png_ptr->width +
+         png_pass_inc[png_ptr->pass] - 1 -
+         png_pass_start[png_ptr->pass]) /
+         png_pass_inc[png_ptr->pass];
+
+         png_ptr->irowbytes =
+            PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1;
+   }
+   else
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+   {
+      png_ptr->num_rows = png_ptr->height;
+      png_ptr->iwidth = png_ptr->width;
+      png_ptr->irowbytes = png_ptr->rowbytes + 1;
+   }
+   max_pixel_depth = png_ptr->pixel_depth;
+
+#ifdef PNG_READ_PACK_SUPPORTED
+   if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
+      max_pixel_depth = 8;
+#endif
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+   if (png_ptr->transformations & PNG_EXPAND)
+   {
+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         if (png_ptr->num_trans)
+            max_pixel_depth = 32;
+         else
+            max_pixel_depth = 24;
+      }
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+      {
+         if (max_pixel_depth < 8)
+            max_pixel_depth = 8;
+         if (png_ptr->num_trans)
+            max_pixel_depth *= 2;
+      }
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+      {
+         if (png_ptr->num_trans)
+         {
+            max_pixel_depth *= 4;
+            max_pixel_depth /= 3;
+         }
+      }
+   }
+#endif
+
+#ifdef PNG_READ_FILLER_SUPPORTED
+   if (png_ptr->transformations & (PNG_FILLER))
+   {
+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+         max_pixel_depth = 32;
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+      {
+         if (max_pixel_depth <= 8)
+            max_pixel_depth = 16;
+         else
+            max_pixel_depth = 32;
+      }
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+      {
+         if (max_pixel_depth <= 32)
+            max_pixel_depth = 32;
+         else
+            max_pixel_depth = 64;
+      }
+   }
+#endif
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+   if (png_ptr->transformations & PNG_GRAY_TO_RGB)
+   {
+      if (
+#ifdef PNG_READ_EXPAND_SUPPORTED
+        (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
+#endif
+#ifdef PNG_READ_FILLER_SUPPORTED
+        (png_ptr->transformations & (PNG_FILLER)) ||
+#endif
+        png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         if (max_pixel_depth <= 16)
+            max_pixel_depth = 32;
+         else
+            max_pixel_depth = 64;
+      }
+      else
+      {
+         if (max_pixel_depth <= 8)
+           {
+             if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+               max_pixel_depth = 32;
+             else
+               max_pixel_depth = 24;
+           }
+         else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+            max_pixel_depth = 64;
+         else
+            max_pixel_depth = 48;
+      }
+   }
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \
+defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+     {
+       int user_pixel_depth = png_ptr->user_transform_depth*
+         png_ptr->user_transform_channels;
+       if (user_pixel_depth > max_pixel_depth)
+         max_pixel_depth=user_pixel_depth;
+     }
+#endif
+
+   /* Align the width on the next larger 8 pixels.  Mainly used
+    * for interlacing
+    */
+   row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
+   /* Calculate the maximum bytes needed, adding a byte and a pixel
+    * for safety's sake
+    */
+   row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +
+      1 + ((max_pixel_depth + 7) >> 3);
+#ifdef PNG_MAX_MALLOC_64K
+   if (row_bytes > (png_uint_32)65536L)
+      png_error(png_ptr, "This image requires a row greater than 64KB");
+#endif
+
+   if (row_bytes + 48 > png_ptr->old_big_row_buf_size)
+   {
+     png_free(png_ptr, png_ptr->big_row_buf);
+     if (png_ptr->interlaced)
+        png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
+            row_bytes + 48);
+     else
+        png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,
+            row_bytes + 48);
+     png_ptr->old_big_row_buf_size = row_bytes + 48;
+
+#ifdef PNG_ALIGNED_MEMORY_SUPPORTED
+     /* Use 16-byte aligned memory for row_buf with at least 16 bytes
+      * of padding before and after row_buf.
+      */
+     png_ptr->row_buf = png_ptr->big_row_buf + 32
+         - (((png_alloc_size_t)&(png_ptr->big_row_buf[0]) + 15) % 16);
+     png_ptr->old_big_row_buf_size = row_bytes + 48;
+#else
+     /* Use 32 bytes of padding before and 16 bytes after row_buf. */
+     png_ptr->row_buf = png_ptr->big_row_buf + 32;
+#endif
+     png_ptr->old_big_row_buf_size = row_bytes + 48;
+   }
+
+#ifdef PNG_MAX_MALLOC_64K
+   if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)
+      png_error(png_ptr, "This image requires a row greater than 64KB");
+#endif
+   if ((png_uint_32)png_ptr->rowbytes > (png_uint_32)(PNG_SIZE_MAX - 1))
+      png_error(png_ptr, "Row has too many bytes to allocate in memory");
+
+   if (png_ptr->rowbytes + 1 > png_ptr->old_prev_row_size)
+   {
+      png_free(png_ptr, png_ptr->prev_row);
+      png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
+        png_ptr->rowbytes + 1));
+      png_ptr->old_prev_row_size = png_ptr->rowbytes + 1;
+   }
+
+   png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+
+   png_debug1(3, "width = %lu,", png_ptr->width);
+   png_debug1(3, "height = %lu,", png_ptr->height);
+   png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);
+   png_debug1(3, "num_rows = %lu,", png_ptr->num_rows);
+   png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);
+   png_debug1(3, "irowbytes = %lu", png_ptr->irowbytes);
+
+   png_ptr->flags |= PNG_FLAG_ROW_INIT;
+}
+#endif /* PNG_READ_SUPPORTED */
diff --git a/src/libpng/pngset.c b/src/libpng/pngset.c
index 1e757a664..adb401604 100644
--- a/src/libpng/pngset.c
+++ b/src/libpng/pngset.c
@@ -1,1229 +1,1163 @@
-

-/* pngset.c - storage of image information into info struct

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * The functions here are used during reads to store data from the file

- * into the info struct, and during writes to store application data

- * into the info struct for writing into the file.  This abstracts the

- * info struct and allows us to change the structure in the future.

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-

-#ifdef PNG_bKGD_SUPPORTED

-void PNGAPI

-png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)

-{

-   png_debug1(1, "in %s storage function", "bKGD");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));

-   info_ptr->valid |= PNG_INFO_bKGD;

-}

-#endif

-

-#ifdef PNG_cHRM_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-void PNGAPI

-png_set_cHRM(png_structp png_ptr, png_infop info_ptr,

-   double white_x, double white_y, double red_x, double red_y,

-   double green_x, double green_y, double blue_x, double blue_y)

-{

-   png_debug1(1, "in %s storage function", "cHRM");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   info_ptr->x_white = (float)white_x;

-   info_ptr->y_white = (float)white_y;

-   info_ptr->x_red   = (float)red_x;

-   info_ptr->y_red   = (float)red_y;

-   info_ptr->x_green = (float)green_x;

-   info_ptr->y_green = (float)green_y;

-   info_ptr->x_blue  = (float)blue_x;

-   info_ptr->y_blue  = (float)blue_y;

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);

-   info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);

-   info_ptr->int_x_red   = (png_fixed_point)(  red_x*100000.+0.5);

-   info_ptr->int_y_red   = (png_fixed_point)(  red_y*100000.+0.5);

-   info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);

-   info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);

-   info_ptr->int_x_blue  = (png_fixed_point)( blue_x*100000.+0.5);

-   info_ptr->int_y_blue  = (png_fixed_point)( blue_y*100000.+0.5);

-#endif

-   info_ptr->valid |= PNG_INFO_cHRM;

-}

-#endif /* PNG_FLOATING_POINT_SUPPORTED */

-

-#ifdef PNG_FIXED_POINT_SUPPORTED

-void PNGAPI

-png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,

-   png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

-   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

-   png_fixed_point blue_x, png_fixed_point blue_y)

-{

-   png_debug1(1, "in %s storage function", "cHRM fixed");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-#ifdef PNG_CHECK_cHRM_SUPPORTED

-   if (png_check_cHRM_fixed(png_ptr,

-      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))

-#endif

-   {

-      info_ptr->int_x_white = white_x;

-      info_ptr->int_y_white = white_y;

-      info_ptr->int_x_red   = red_x;

-      info_ptr->int_y_red   = red_y;

-      info_ptr->int_x_green = green_x;

-      info_ptr->int_y_green = green_y;

-      info_ptr->int_x_blue  = blue_x;

-      info_ptr->int_y_blue  = blue_y;

-#ifdef  PNG_FLOATING_POINT_SUPPORTED

-      info_ptr->x_white = (float)(white_x/100000.);

-      info_ptr->y_white = (float)(white_y/100000.);

-      info_ptr->x_red   = (float)(  red_x/100000.);

-      info_ptr->y_red   = (float)(  red_y/100000.);

-      info_ptr->x_green = (float)(green_x/100000.);

-      info_ptr->y_green = (float)(green_y/100000.);

-      info_ptr->x_blue  = (float)( blue_x/100000.);

-      info_ptr->y_blue  = (float)( blue_y/100000.);

-#endif

-      info_ptr->valid |= PNG_INFO_cHRM;

-   }

-}

-#endif /* PNG_FIXED_POINT_SUPPORTED */

-#endif /* PNG_cHRM_SUPPORTED */

-

-#ifdef PNG_gAMA_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-void PNGAPI

-png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)

-{

-   double png_gamma;

-

-   png_debug1(1, "in %s storage function", "gAMA");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   /* Check for overflow */

-   if (file_gamma > 21474.83)

-   {

-      png_warning(png_ptr, "Limiting gamma to 21474.83");

-      png_gamma=21474.83;

-   }

-   else

-      png_gamma = file_gamma;

-   info_ptr->gamma = (float)png_gamma;

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   info_ptr->int_gamma = (int)(png_gamma*100000.+.5);

-#endif

-   info_ptr->valid |= PNG_INFO_gAMA;

-   if (png_gamma == 0.0)

-      png_warning(png_ptr, "Setting gamma=0");

-}

-#endif

-void PNGAPI

-png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point

-   int_gamma)

-{

-   png_fixed_point png_gamma;

-

-   png_debug1(1, "in %s storage function", "gAMA");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)

-   {

-      png_warning(png_ptr, "Limiting gamma to 21474.83");

-      png_gamma=PNG_UINT_31_MAX;

-   }

-   else

-   {

-      if (int_gamma < 0)

-      {

-         png_warning(png_ptr, "Setting negative gamma to zero");

-         png_gamma = 0;

-      }

-      else

-         png_gamma = int_gamma;

-   }

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   info_ptr->gamma = (float)(png_gamma/100000.);

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   info_ptr->int_gamma = png_gamma;

-#endif

-   info_ptr->valid |= PNG_INFO_gAMA;

-   if (png_gamma == 0)

-      png_warning(png_ptr, "Setting gamma=0");

-}

-#endif

-

-#ifdef PNG_hIST_SUPPORTED

-void PNGAPI

-png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)

-{

-   int i;

-

-   png_debug1(1, "in %s storage function", "hIST");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   if (info_ptr->num_palette == 0 || info_ptr->num_palette

-       > PNG_MAX_PALETTE_LENGTH)

-   {

-      png_warning(png_ptr,

-         "Invalid palette size, hIST allocation skipped.");

-      return;

-   }

-

-#ifdef PNG_FREE_ME_SUPPORTED

-   png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);

-#endif

-   /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in

-    * version 1.2.1

-    */

-   png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,

-      (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)));

-   if (png_ptr->hist == NULL)

-   {

-      png_warning(png_ptr, "Insufficient memory for hIST chunk data.");

-      return;

-   }

-

-   for (i = 0; i < info_ptr->num_palette; i++)

-      png_ptr->hist[i] = hist[i];

-   info_ptr->hist = png_ptr->hist;

-   info_ptr->valid |= PNG_INFO_hIST;

-

-#ifdef PNG_FREE_ME_SUPPORTED

-   info_ptr->free_me |= PNG_FREE_HIST;

-#else

-   png_ptr->flags |= PNG_FLAG_FREE_HIST;

-#endif

-}

-#endif

-

-void PNGAPI

-png_set_IHDR(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_type, int compression_type,

-   int filter_type)

-{

-   png_debug1(1, "in %s storage function", "IHDR");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   info_ptr->width = width;

-   info_ptr->height = height;

-   info_ptr->bit_depth = (png_byte)bit_depth;

-   info_ptr->color_type = (png_byte)color_type;

-   info_ptr->compression_type = (png_byte)compression_type;

-   info_ptr->filter_type = (png_byte)filter_type;

-   info_ptr->interlace_type = (png_byte)interlace_type;

-

-   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,

-       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

-       info_ptr->compression_type, info_ptr->filter_type);

-

-   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      info_ptr->channels = 1;

-   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)

-      info_ptr->channels = 3;

-   else

-      info_ptr->channels = 1;

-   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

-      info_ptr->channels++;

-   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);

-

-   /* Check for potential overflow */

-   if (width > (PNG_UINT_32_MAX

-                 >> 3)      /* 8-byte RGBA pixels */

-                 - 64       /* bigrowbuf hack */

-                 - 1        /* filter byte */

-                 - 7*8      /* rounding of width to multiple of 8 pixels */

-                 - 8)       /* extra max_pixel_depth pad */

-      info_ptr->rowbytes = (png_size_t)0;

-   else

-      info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);

-}

-

-#ifdef PNG_oFFs_SUPPORTED

-void PNGAPI

-png_set_oFFs(png_structp png_ptr, png_infop info_ptr,

-   png_int_32 offset_x, png_int_32 offset_y, int unit_type)

-{

-   png_debug1(1, "in %s storage function", "oFFs");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   info_ptr->x_offset = offset_x;

-   info_ptr->y_offset = offset_y;

-   info_ptr->offset_unit_type = (png_byte)unit_type;

-   info_ptr->valid |= PNG_INFO_oFFs;

-}

-#endif

-

-#ifdef PNG_pCAL_SUPPORTED

-void PNGAPI

-png_set_pCAL(png_structp png_ptr, png_infop info_ptr,

-   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,

-   png_charp units, png_charpp params)

-{

-   png_uint_32 length;

-   int i;

-

-   png_debug1(1, "in %s storage function", "pCAL");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   length = png_strlen(purpose) + 1;

-   png_debug1(3, "allocating purpose for info (%lu bytes)",

-     (unsigned long)length);

-   info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);

-   if (info_ptr->pcal_purpose == NULL)

-   {

-      png_warning(png_ptr, "Insufficient memory for pCAL purpose.");

-      return;

-   }

-   png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);

-

-   png_debug(3, "storing X0, X1, type, and nparams in info");

-   info_ptr->pcal_X0 = X0;

-   info_ptr->pcal_X1 = X1;

-   info_ptr->pcal_type = (png_byte)type;

-   info_ptr->pcal_nparams = (png_byte)nparams;

-

-   length = png_strlen(units) + 1;

-   png_debug1(3, "allocating units for info (%lu bytes)",

-     (unsigned long)length);

-   info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);

-   if (info_ptr->pcal_units == NULL)

-   {

-      png_warning(png_ptr, "Insufficient memory for pCAL units.");

-      return;

-   }

-   png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);

-

-   info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,

-      (png_uint_32)((nparams + 1) * png_sizeof(png_charp)));

-   if (info_ptr->pcal_params == NULL)

-   {

-      png_warning(png_ptr, "Insufficient memory for pCAL params.");

-      return;

-   }

-

-   png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));

-

-   for (i = 0; i < nparams; i++)

-   {

-      length = png_strlen(params[i]) + 1;

-      png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,

-        (unsigned long)length);

-      info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);

-      if (info_ptr->pcal_params[i] == NULL)

-      {

-         png_warning(png_ptr, "Insufficient memory for pCAL parameter.");

-         return;

-      }

-      png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);

-   }

-

-   info_ptr->valid |= PNG_INFO_pCAL;

-#ifdef PNG_FREE_ME_SUPPORTED

-   info_ptr->free_me |= PNG_FREE_PCAL;

-#endif

-}

-#endif

-

-#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-void PNGAPI

-png_set_sCAL(png_structp png_ptr, png_infop info_ptr,

-             int unit, double width, double height)

-{

-   png_debug1(1, "in %s storage function", "sCAL");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   info_ptr->scal_unit = (png_byte)unit;

-   info_ptr->scal_pixel_width = width;

-   info_ptr->scal_pixel_height = height;

-

-   info_ptr->valid |= PNG_INFO_sCAL;

-}

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-void PNGAPI

-png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,

-             int unit, png_charp swidth, png_charp sheight)

-{

-   png_uint_32 length;

-

-   png_debug1(1, "in %s storage function", "sCAL");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   info_ptr->scal_unit = (png_byte)unit;

-

-   length = png_strlen(swidth) + 1;

-   png_debug1(3, "allocating unit for info (%u bytes)",

-      (unsigned int)length);

-   info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);

-   if (info_ptr->scal_s_width == NULL)

-   {

-      png_warning(png_ptr,

-       "Memory allocation failed while processing sCAL.");

-      return;

-   }

-   png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);

-

-   length = png_strlen(sheight) + 1;

-   png_debug1(3, "allocating unit for info (%u bytes)",

-      (unsigned int)length);

-   info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);

-   if (info_ptr->scal_s_height == NULL)

-   {

-      png_free (png_ptr, info_ptr->scal_s_width);

-      info_ptr->scal_s_width = NULL;

-      png_warning(png_ptr,

-       "Memory allocation failed while processing sCAL.");

-      return;

-   }

-   png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);

-   info_ptr->valid |= PNG_INFO_sCAL;

-#ifdef PNG_FREE_ME_SUPPORTED

-   info_ptr->free_me |= PNG_FREE_SCAL;

-#endif

-}

-#endif

-#endif

-#endif

-

-#ifdef PNG_pHYs_SUPPORTED

-void PNGAPI

-png_set_pHYs(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 res_x, png_uint_32 res_y, int unit_type)

-{

-   png_debug1(1, "in %s storage function", "pHYs");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   info_ptr->x_pixels_per_unit = res_x;

-   info_ptr->y_pixels_per_unit = res_y;

-   info_ptr->phys_unit_type = (png_byte)unit_type;

-   info_ptr->valid |= PNG_INFO_pHYs;

-}

-#endif

-

-void PNGAPI

-png_set_PLTE(png_structp png_ptr, png_infop info_ptr,

-   png_colorp palette, int num_palette)

-{

-

-   png_debug1(1, "in %s storage function", "PLTE");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)

-   {

-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-         png_error(png_ptr, "Invalid palette length");

-      else

-      {

-         png_warning(png_ptr, "Invalid palette length");

-         return;

-      }

-   }

-

-   /*

-    * It may not actually be necessary to set png_ptr->palette here;

-    * we do it for backward compatibility with the way the png_handle_tRNS

-    * function used to do the allocation.

-    */

-#ifdef PNG_FREE_ME_SUPPORTED

-   png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);

-#endif

-

-   /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead

-    * of num_palette entries, in case of an invalid PNG file that has

-    * too-large sample values.

-    */

-   png_ptr->palette = (png_colorp)png_calloc(png_ptr,

-      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));

-   png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));

-   info_ptr->palette = png_ptr->palette;

-   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;

-

-#ifdef PNG_FREE_ME_SUPPORTED

-   info_ptr->free_me |= PNG_FREE_PLTE;

-#else

-   png_ptr->flags |= PNG_FLAG_FREE_PLTE;

-#endif

-

-   info_ptr->valid |= PNG_INFO_PLTE;

-}

-

-#ifdef PNG_sBIT_SUPPORTED

-void PNGAPI

-png_set_sBIT(png_structp png_ptr, png_infop info_ptr,

-   png_color_8p sig_bit)

-{

-   png_debug1(1, "in %s storage function", "sBIT");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));

-   info_ptr->valid |= PNG_INFO_sBIT;

-}

-#endif

-

-#ifdef PNG_sRGB_SUPPORTED

-void PNGAPI

-png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)

-{

-   png_debug1(1, "in %s storage function", "sRGB");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   info_ptr->srgb_intent = (png_byte)intent;

-   info_ptr->valid |= PNG_INFO_sRGB;

-}

-

-void PNGAPI

-png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,

-   int intent)

-{

-#ifdef PNG_gAMA_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   float file_gamma;

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   png_fixed_point int_file_gamma;

-#endif

-#endif

-#ifdef PNG_cHRM_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

-#endif

-   png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,

-      int_green_y, int_blue_x, int_blue_y;

-#endif

-   png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   png_set_sRGB(png_ptr, info_ptr, intent);

-

-#ifdef PNG_gAMA_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   file_gamma = (float).45455;

-   png_set_gAMA(png_ptr, info_ptr, file_gamma);

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   int_file_gamma = 45455L;

-   png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);

-#endif

-#endif

-

-#ifdef PNG_cHRM_SUPPORTED

-   int_white_x = 31270L;

-   int_white_y = 32900L;

-   int_red_x   = 64000L;

-   int_red_y   = 33000L;

-   int_green_x = 30000L;

-   int_green_y = 60000L;

-   int_blue_x  = 15000L;

-   int_blue_y  =  6000L;

-

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   white_x = (float).3127;

-   white_y = (float).3290;

-   red_x   = (float).64;

-   red_y   = (float).33;

-   green_x = (float).30;

-   green_y = (float).60;

-   blue_x  = (float).15;

-   blue_y  = (float).06;

-#endif

-

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   png_set_cHRM_fixed(png_ptr, info_ptr,

-       int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,

-       int_green_y, int_blue_x, int_blue_y);

-#endif

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   png_set_cHRM(png_ptr, info_ptr,

-       white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);

-#endif

-#endif /* cHRM */

-}

-#endif /* sRGB */

-

-

-#ifdef PNG_iCCP_SUPPORTED

-void PNGAPI

-png_set_iCCP(png_structp png_ptr, png_infop info_ptr,

-             png_charp name, int compression_type,

-             png_charp profile, png_uint_32 proflen)

-{

-   png_charp new_iccp_name;

-   png_charp new_iccp_profile;

-   png_uint_32 length;

-

-   png_debug1(1, "in %s storage function", "iCCP");

-

-   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)

-      return;

-

-   length = png_strlen(name)+1;

-   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);

-   if (new_iccp_name == NULL)

-   {

-      png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");

-      return;

-   }

-   png_memcpy(new_iccp_name, name, length);

-   new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);

-   if (new_iccp_profile == NULL)

-   {

-      png_free (png_ptr, new_iccp_name);

-      png_warning(png_ptr,

-      "Insufficient memory to process iCCP profile.");

-      return;

-   }

-   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);

-

-   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);

-

-   info_ptr->iccp_proflen = proflen;

-   info_ptr->iccp_name = new_iccp_name;

-   info_ptr->iccp_profile = new_iccp_profile;

-   /* Compression is always zero but is here so the API and info structure

-    * does not have to change if we introduce multiple compression types */

-   info_ptr->iccp_compression = (png_byte)compression_type;

-#ifdef PNG_FREE_ME_SUPPORTED

-   info_ptr->free_me |= PNG_FREE_ICCP;

-#endif

-   info_ptr->valid |= PNG_INFO_iCCP;

-}

-#endif

-

-#ifdef PNG_TEXT_SUPPORTED

-void PNGAPI

-png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,

-             int num_text)

-{

-   int ret;

-   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);

-   if (ret)

-      png_error(png_ptr, "Insufficient memory to store text");

-}

-

-int /* PRIVATE */

-png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,

-               int num_text)

-{

-   int i;

-

-   png_debug1(1, "in %s storage function", ((png_ptr == NULL ||

-      png_ptr->chunk_name[0] == '\0') ?

-      "text" : (png_const_charp)png_ptr->chunk_name));

-

-   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)

-      return(0);

-

-   /* Make sure we have enough space in the "text" array in info_struct

-    * to hold all of the incoming text_ptr objects.

-    */

-   if (info_ptr->num_text + num_text > info_ptr->max_text)

-   {

-      if (info_ptr->text != NULL)

-      {

-         png_textp old_text;

-         int old_max;

-

-         old_max = info_ptr->max_text;

-         info_ptr->max_text = info_ptr->num_text + num_text + 8;

-         old_text = info_ptr->text;

-         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

-            (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));

-         if (info_ptr->text == NULL)

-         {

-            png_free(png_ptr, old_text);

-            return(1);

-         }

-         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *

-            png_sizeof(png_text)));

-         png_free(png_ptr, old_text);

-      }

-      else

-      {

-         info_ptr->max_text = num_text + 8;

-         info_ptr->num_text = 0;

-         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

-            (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));

-         if (info_ptr->text == NULL)

-            return(1);

-#ifdef PNG_FREE_ME_SUPPORTED

-         info_ptr->free_me |= PNG_FREE_TEXT;

-#endif

-      }

-      png_debug1(3, "allocated %d entries for info_ptr->text",

-         info_ptr->max_text);

-   }

-   for (i = 0; i < num_text; i++)

-   {

-      png_size_t text_length, key_len;

-      png_size_t lang_len, lang_key_len;

-      png_textp textp = &(info_ptr->text[info_ptr->num_text]);

-

-      if (text_ptr[i].key == NULL)

-          continue;

-

-      key_len = png_strlen(text_ptr[i].key);

-

-      if (text_ptr[i].compression <= 0)

-      {

-         lang_len = 0;

-         lang_key_len = 0;

-      }

-

-      else

-#ifdef PNG_iTXt_SUPPORTED

-      {

-         /* Set iTXt data */

-

-         if (text_ptr[i].lang != NULL)

-            lang_len = png_strlen(text_ptr[i].lang);

-         else

-            lang_len = 0;

-         if (text_ptr[i].lang_key != NULL)

-            lang_key_len = png_strlen(text_ptr[i].lang_key);

-         else

-            lang_key_len = 0;

-      }

-#else /* PNG_iTXt_SUPPORTED */

-      {

-         png_warning(png_ptr, "iTXt chunk not supported.");

-         continue;

-      }

-#endif

-

-      if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')

-      {

-         text_length = 0;

-#ifdef PNG_iTXt_SUPPORTED

-         if (text_ptr[i].compression > 0)

-            textp->compression = PNG_ITXT_COMPRESSION_NONE;

-         else

-#endif

-            textp->compression = PNG_TEXT_COMPRESSION_NONE;

-      }

-

-      else

-      {

-         text_length = png_strlen(text_ptr[i].text);

-         textp->compression = text_ptr[i].compression;

-      }

-

-      textp->key = (png_charp)png_malloc_warn(png_ptr,

-         (png_uint_32)

-         (key_len + text_length + lang_len + lang_key_len + 4));

-      if (textp->key == NULL)

-         return(1);

-      png_debug2(2, "Allocated %lu bytes at %x in png_set_text",

-                 (png_uint_32)

-                 (key_len + lang_len + lang_key_len + text_length + 4),

-                 (int)textp->key);

-

-      png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));

-      *(textp->key + key_len) = '\0';

-#ifdef PNG_iTXt_SUPPORTED

-      if (text_ptr[i].compression > 0)

-      {

-         textp->lang = textp->key + key_len + 1;

-         png_memcpy(textp->lang, text_ptr[i].lang, lang_len);

-         *(textp->lang + lang_len) = '\0';

-         textp->lang_key = textp->lang + lang_len + 1;

-         png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);

-         *(textp->lang_key + lang_key_len) = '\0';

-         textp->text = textp->lang_key + lang_key_len + 1;

-      }

-      else

-#endif

-      {

-#ifdef PNG_iTXt_SUPPORTED

-         textp->lang=NULL;

-         textp->lang_key=NULL;

-#endif

-         textp->text = textp->key + key_len + 1;

-      }

-      if (text_length)

-         png_memcpy(textp->text, text_ptr[i].text,

-            (png_size_t)(text_length));

-      *(textp->text + text_length) = '\0';

-

-#ifdef PNG_iTXt_SUPPORTED

-      if (textp->compression > 0)

-      {

-         textp->text_length = 0;

-         textp->itxt_length = text_length;

-      }

-      else

-#endif

-

-      {

-         textp->text_length = text_length;

-#ifdef PNG_iTXt_SUPPORTED

-         textp->itxt_length = 0;

-#endif

-      }

-      info_ptr->num_text++;

-      png_debug1(3, "transferred text chunk %d", info_ptr->num_text);

-   }

-   return(0);

-}

-#endif

-

-#ifdef PNG_tIME_SUPPORTED

-void PNGAPI

-png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)

-{

-   png_debug1(1, "in %s storage function", "tIME");

-

-   if (png_ptr == NULL || info_ptr == NULL ||

-       (png_ptr->mode & PNG_WROTE_tIME))

-      return;

-

-   png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));

-   info_ptr->valid |= PNG_INFO_tIME;

-}

-#endif

-

-#ifdef PNG_tRNS_SUPPORTED

-void PNGAPI

-png_set_tRNS(png_structp png_ptr, png_infop info_ptr,

-   png_bytep trans, int num_trans, png_color_16p trans_values)

-{

-   png_debug1(1, "in %s storage function", "tRNS");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   if (trans != NULL)

-   {

-       /* It may not actually be necessary to set png_ptr->trans here;

-        * we do it for backward compatibility with the way the png_handle_tRNS

-        * function used to do the allocation.

-        */

-

-#ifdef PNG_FREE_ME_SUPPORTED

-       png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);

-#endif

-

-       /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */

-       png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,

-           (png_uint_32)PNG_MAX_PALETTE_LENGTH);

-       if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)

-          png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);

-   }

-

-   if (trans_values != NULL)

-   {

-      int sample_max = (1 << info_ptr->bit_depth);

-      if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&

-          (int)trans_values->gray > sample_max) ||

-          (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&

-          ((int)trans_values->red > sample_max ||

-          (int)trans_values->green > sample_max ||

-          (int)trans_values->blue > sample_max)))

-         png_warning(png_ptr,

-            "tRNS chunk has out-of-range samples for bit_depth");

-      png_memcpy(&(info_ptr->trans_values), trans_values,

-         png_sizeof(png_color_16));

-      if (num_trans == 0)

-         num_trans = 1;

-   }

-

-   info_ptr->num_trans = (png_uint_16)num_trans;

-   if (num_trans != 0)

-   {

-      info_ptr->valid |= PNG_INFO_tRNS;

-#ifdef PNG_FREE_ME_SUPPORTED

-      info_ptr->free_me |= PNG_FREE_TRNS;

-#else

-      png_ptr->flags |= PNG_FLAG_FREE_TRNS;

-#endif

-   }

-}

-#endif

-

-#ifdef PNG_sPLT_SUPPORTED

-void PNGAPI

-png_set_sPLT(png_structp png_ptr,

-             png_infop info_ptr, png_sPLT_tp entries, int nentries)

-/*

- *  entries        - array of png_sPLT_t structures

- *                   to be added to the list of palettes

- *                   in the info structure.

- *  nentries       - number of palette structures to be

- *                   added.

- */

-{

-   png_sPLT_tp np;

-   int i;

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   np = (png_sPLT_tp)png_malloc_warn(png_ptr,

-       (info_ptr->splt_palettes_num + nentries) *

-        (png_uint_32)png_sizeof(png_sPLT_t));

-   if (np == NULL)

-   {

-      png_warning(png_ptr, "No memory for sPLT palettes.");

-     return;

-   }

-

-   png_memcpy(np, info_ptr->splt_palettes,

-          info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));

-   png_free(png_ptr, info_ptr->splt_palettes);

-   info_ptr->splt_palettes=NULL;

-

-   for (i = 0; i < nentries; i++)

-   {

-      png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;

-      png_sPLT_tp from = entries + i;

-      png_uint_32 length;

-

-      length = png_strlen(from->name) + 1;

-        to->name = (png_charp)png_malloc_warn(png_ptr, length);

-      if (to->name == NULL)

-      {

-         png_warning(png_ptr,

-           "Out of memory while processing sPLT chunk");

-         continue;

-      }

-      png_memcpy(to->name, from->name, length);

-      to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,

-            (png_uint_32)(from->nentries * png_sizeof(png_sPLT_entry)));

-      if (to->entries == NULL)

-      {

-         png_warning(png_ptr,

-           "Out of memory while processing sPLT chunk");

-         png_free(png_ptr, to->name);

-         to->name = NULL;

-         continue;

-      }

-      png_memcpy(to->entries, from->entries,

-          from->nentries * png_sizeof(png_sPLT_entry));

-      to->nentries = from->nentries;

-      to->depth = from->depth;

-   }

-

-   info_ptr->splt_palettes = np;

-   info_ptr->splt_palettes_num += nentries;

-   info_ptr->valid |= PNG_INFO_sPLT;

-#ifdef PNG_FREE_ME_SUPPORTED

-   info_ptr->free_me |= PNG_FREE_SPLT;

-#endif

-}

-#endif /* PNG_sPLT_SUPPORTED */

-

-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-void PNGAPI

-png_set_unknown_chunks(png_structp png_ptr,

-   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)

-{

-   png_unknown_chunkp np;

-   int i;

-

-   if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)

-      return;

-

-   np = (png_unknown_chunkp)png_malloc_warn(png_ptr,

-       (png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *

-       png_sizeof(png_unknown_chunk)));

-   if (np == NULL)

-   {

-      png_warning(png_ptr,

-         "Out of memory while processing unknown chunk.");

-      return;

-   }

-

-   png_memcpy(np, info_ptr->unknown_chunks,

-          info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));

-   png_free(png_ptr, info_ptr->unknown_chunks);

-   info_ptr->unknown_chunks=NULL;

-

-   for (i = 0; i < num_unknowns; i++)

-   {

-      png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;

-      png_unknown_chunkp from = unknowns + i;

-

-      png_memcpy((png_charp)to->name,

-                 (png_charp)from->name,

-                 png_sizeof(from->name));

-      to->name[png_sizeof(to->name)-1] = '\0';

-      to->size = from->size;

-      /* Note our location in the read or write sequence */

-      to->location = (png_byte)(png_ptr->mode & 0xff);

-

-      if (from->size == 0)

-         to->data=NULL;

-      else

-      {

-         to->data = (png_bytep)png_malloc_warn(png_ptr,

-           (png_uint_32)from->size);

-         if (to->data == NULL)

-         {

-            png_warning(png_ptr,

-             "Out of memory while processing unknown chunk.");

-            to->size = 0;

-         }

-         else

-            png_memcpy(to->data, from->data, from->size);

-      }

-   }

-

-   info_ptr->unknown_chunks = np;

-   info_ptr->unknown_chunks_num += num_unknowns;

-#ifdef PNG_FREE_ME_SUPPORTED

-   info_ptr->free_me |= PNG_FREE_UNKN;

-#endif

-}

-void PNGAPI

-png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,

-   int chunk, int location)

-{

-   if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <

-         (int)info_ptr->unknown_chunks_num)

-      info_ptr->unknown_chunks[chunk].location = (png_byte)location;

-}

-#endif

-

-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

-#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \

-    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)

-void PNGAPI

-png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)

-{

-   /* This function is deprecated in favor of png_permit_mng_features()

-      and will be removed from libpng-1.3.0 */

-

-   png_debug(1, "in png_permit_empty_plte, DEPRECATED.");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->mng_features_permitted = (png_byte)

-     ((png_ptr->mng_features_permitted & (~PNG_FLAG_MNG_EMPTY_PLTE)) |

-     ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));

-}

-#endif

-#endif

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-png_uint_32 PNGAPI

-png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)

-{

-   png_debug(1, "in png_permit_mng_features");

-

-   if (png_ptr == NULL)

-      return (png_uint_32)0;

-   png_ptr->mng_features_permitted =

-     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);

-   return (png_uint_32)png_ptr->mng_features_permitted;

-}

-#endif

-

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-void PNGAPI

-png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep

-   chunk_list, int num_chunks)

-{

-   png_bytep new_list, p;

-   int i, old_num_chunks;

-   if (png_ptr == NULL)

-      return;

-   if (num_chunks == 0)

-   {

-      if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)

-         png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

-      else

-         png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

-

-      if (keep == PNG_HANDLE_CHUNK_ALWAYS)

-         png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;

-      else

-         png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;

-      return;

-   }

-   if (chunk_list == NULL)

-      return;

-   old_num_chunks = png_ptr->num_chunk_list;

-   new_list=(png_bytep)png_malloc(png_ptr,

-      (png_uint_32)

-      (5*(num_chunks + old_num_chunks)));

-   if (png_ptr->chunk_list != NULL)

-   {

-      png_memcpy(new_list, png_ptr->chunk_list,

-         (png_size_t)(5*old_num_chunks));

-      png_free(png_ptr, png_ptr->chunk_list);

-      png_ptr->chunk_list=NULL;

-   }

-   png_memcpy(new_list + 5*old_num_chunks, chunk_list,

-      (png_size_t)(5*num_chunks));

-   for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)

-      *p=(png_byte)keep;

-   png_ptr->num_chunk_list = old_num_chunks + num_chunks;

-   png_ptr->chunk_list = new_list;

-#ifdef PNG_FREE_ME_SUPPORTED

-   png_ptr->free_me |= PNG_FREE_LIST;

-#endif

-}

-#endif

-

-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-void PNGAPI

-png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,

-   png_user_chunk_ptr read_user_chunk_fn)

-{

-   png_debug(1, "in png_set_read_user_chunk_fn");

-

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->read_user_chunk_fn = read_user_chunk_fn;

-   png_ptr->user_chunk_ptr = user_chunk_ptr;

-}

-#endif

-

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-void PNGAPI

-png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)

-{

-   png_debug1(1, "in %s storage function", "rows");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))

-      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

-   info_ptr->row_pointers = row_pointers;

-   if (row_pointers)

-      info_ptr->valid |= PNG_INFO_IDAT;

-}

-#endif

-

-#ifdef PNG_WRITE_SUPPORTED

-void PNGAPI

-png_set_compression_buffer_size(png_structp png_ptr,

-    png_uint_32 size)

-{

-    if (png_ptr == NULL)

-       return;

-    png_free(png_ptr, png_ptr->zbuf);

-    png_ptr->zbuf_size = (png_size_t)size;

-    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);

-    png_ptr->zstream.next_out = png_ptr->zbuf;

-    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-}

-#endif

-

-void PNGAPI

-png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)

-{

-   if (png_ptr && info_ptr)

-      info_ptr->valid &= ~mask;

-}

-

-

-#ifndef PNG_1_0_X

-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

-/* Function was added to libpng 1.2.0 and should always exist by default */

-void PNGAPI

-png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)

-{

-/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */

-    if (png_ptr != NULL)

-    png_ptr->asm_flags = 0;

-    asm_flags = asm_flags; /* Quiet the compiler */

-}

-

-/* This function was added to libpng 1.2.0 */

-void PNGAPI

-png_set_mmx_thresholds (png_structp png_ptr,

-                        png_byte mmx_bitdepth_threshold,

-                        png_uint_32 mmx_rowbytes_threshold)

-{

-/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */

-    if (png_ptr == NULL)

-       return;

-    /* Quiet the compiler */

-    mmx_bitdepth_threshold = mmx_bitdepth_threshold;

-    mmx_rowbytes_threshold = mmx_rowbytes_threshold;

-}

-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */

-

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-/* This function was added to libpng 1.2.6 */

-void PNGAPI

-png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,

-    png_uint_32 user_height_max)

-{

-   /* Images with dimensions larger than these limits will be

-    * rejected by png_set_IHDR().  To accept any PNG datastream

-    * regardless of dimensions, set both limits to 0x7ffffffL.

-    */

-   if (png_ptr == NULL)

-      return;

-   png_ptr->user_width_max = user_width_max;

-   png_ptr->user_height_max = user_height_max;

-}

-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */

-

-

-#ifdef PNG_BENIGN_ERRORS_SUPPORTED

-void PNGAPI

-png_set_benign_errors(png_structp png_ptr, int allowed)

-{

-   png_debug(1, "in png_set_benign_errors");

-

-   if (allowed)

-      png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;

-   else

-      png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;

-}

-#endif /* PNG_BENIGN_ERRORS_SUPPORTED */

-#endif /* ?PNG_1_0_X */

-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

+
+/* pngset.c - storage of image information into info struct
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * The functions here are used during reads to store data from the file
+ * into the info struct, and during writes to store application data
+ * into the info struct for writing into the file.  This abstracts the
+ * info struct and allows us to change the structure in the future.
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#include "pngpriv.h"
+
+#ifdef PNG_bKGD_SUPPORTED
+void PNGAPI
+png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
+{
+   png_debug1(1, "in %s storage function", "bKGD");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
+   info_ptr->valid |= PNG_INFO_bKGD;
+}
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void PNGAPI
+png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
+   double white_x, double white_y, double red_x, double red_y,
+   double green_x, double green_y, double blue_x, double blue_y)
+{
+   png_debug1(1, "in %s storage function", "cHRM");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->x_white = (float)white_x;
+   info_ptr->y_white = (float)white_y;
+   info_ptr->x_red   = (float)red_x;
+   info_ptr->y_red   = (float)red_y;
+   info_ptr->x_green = (float)green_x;
+   info_ptr->y_green = (float)green_y;
+   info_ptr->x_blue  = (float)blue_x;
+   info_ptr->y_blue  = (float)blue_y;
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);
+   info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);
+   info_ptr->int_x_red   = (png_fixed_point)(  red_x*100000.+0.5);
+   info_ptr->int_y_red   = (png_fixed_point)(  red_y*100000.+0.5);
+   info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);
+   info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);
+   info_ptr->int_x_blue  = (png_fixed_point)( blue_x*100000.+0.5);
+   info_ptr->int_y_blue  = (png_fixed_point)( blue_y*100000.+0.5);
+#endif
+   info_ptr->valid |= PNG_INFO_cHRM;
+}
+#endif /* PNG_FLOATING_POINT_SUPPORTED */
+
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void PNGAPI
+png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
+   png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
+   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
+   png_fixed_point blue_x, png_fixed_point blue_y)
+{
+   png_debug1(1, "in %s storage function", "cHRM fixed");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+#ifdef PNG_CHECK_cHRM_SUPPORTED
+   if (png_check_cHRM_fixed(png_ptr,
+      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))
+#endif
+   {
+      info_ptr->int_x_white = white_x;
+      info_ptr->int_y_white = white_y;
+      info_ptr->int_x_red   = red_x;
+      info_ptr->int_y_red   = red_y;
+      info_ptr->int_x_green = green_x;
+      info_ptr->int_y_green = green_y;
+      info_ptr->int_x_blue  = blue_x;
+      info_ptr->int_y_blue  = blue_y;
+#ifdef  PNG_FLOATING_POINT_SUPPORTED
+      info_ptr->x_white = (float)(white_x/100000.);
+      info_ptr->y_white = (float)(white_y/100000.);
+      info_ptr->x_red   = (float)(  red_x/100000.);
+      info_ptr->y_red   = (float)(  red_y/100000.);
+      info_ptr->x_green = (float)(green_x/100000.);
+      info_ptr->y_green = (float)(green_y/100000.);
+      info_ptr->x_blue  = (float)( blue_x/100000.);
+      info_ptr->y_blue  = (float)( blue_y/100000.);
+#endif
+      info_ptr->valid |= PNG_INFO_cHRM;
+   }
+}
+#endif /* PNG_FIXED_POINT_SUPPORTED */
+#endif /* PNG_cHRM_SUPPORTED */
+
+#ifdef PNG_gAMA_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void PNGAPI
+png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
+{
+   double png_gamma;
+
+   png_debug1(1, "in %s storage function", "gAMA");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   /* Check for overflow */
+   if (file_gamma > 21474.83)
+   {
+      png_warning(png_ptr, "Limiting gamma to 21474.83");
+      png_gamma=21474.83;
+   }
+   else
+      png_gamma = file_gamma;
+   info_ptr->gamma = (float)png_gamma;
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   info_ptr->int_gamma = (int)(png_gamma*100000.+.5);
+#endif
+   info_ptr->valid |= PNG_INFO_gAMA;
+   if (png_gamma == 0.0)
+      png_warning(png_ptr, "Setting gamma=0");
+}
+#endif
+void PNGAPI
+png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
+   int_gamma)
+{
+   png_fixed_point png_gamma;
+
+   png_debug1(1, "in %s storage function", "gAMA");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)
+   {
+      png_warning(png_ptr, "Limiting gamma to 21474.83");
+      png_gamma=PNG_UINT_31_MAX;
+   }
+   else
+   {
+      if (int_gamma < 0)
+      {
+         png_warning(png_ptr, "Setting negative gamma to zero");
+         png_gamma = 0;
+      }
+      else
+         png_gamma = int_gamma;
+   }
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   info_ptr->gamma = (float)(png_gamma/100000.);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   info_ptr->int_gamma = png_gamma;
+#endif
+   info_ptr->valid |= PNG_INFO_gAMA;
+   if (png_gamma == 0)
+      png_warning(png_ptr, "Setting gamma=0");
+}
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+void PNGAPI
+png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
+{
+   int i;
+
+   png_debug1(1, "in %s storage function", "hIST");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   if (info_ptr->num_palette == 0 || info_ptr->num_palette
+       > PNG_MAX_PALETTE_LENGTH)
+   {
+      png_warning(png_ptr,
+         "Invalid palette size, hIST allocation skipped");
+      return;
+   }
+
+   png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
+   /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
+    * version 1.2.1
+    */
+   png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
+      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16));
+   if (png_ptr->hist == NULL)
+   {
+      png_warning(png_ptr, "Insufficient memory for hIST chunk data");
+      return;
+   }
+
+   for (i = 0; i < info_ptr->num_palette; i++)
+      png_ptr->hist[i] = hist[i];
+   info_ptr->hist = png_ptr->hist;
+   info_ptr->valid |= PNG_INFO_hIST;
+
+   info_ptr->free_me |= PNG_FREE_HIST;
+}
+#endif
+
+void PNGAPI
+png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 width, png_uint_32 height, int bit_depth,
+   int color_type, int interlace_type, int compression_type,
+   int filter_type)
+{
+   png_debug1(1, "in %s storage function", "IHDR");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->width = width;
+   info_ptr->height = height;
+   info_ptr->bit_depth = (png_byte)bit_depth;
+   info_ptr->color_type = (png_byte)color_type;
+   info_ptr->compression_type = (png_byte)compression_type;
+   info_ptr->filter_type = (png_byte)filter_type;
+   info_ptr->interlace_type = (png_byte)interlace_type;
+
+   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
+       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
+       info_ptr->compression_type, info_ptr->filter_type);
+
+   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      info_ptr->channels = 1;
+   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
+      info_ptr->channels = 3;
+   else
+      info_ptr->channels = 1;
+   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
+      info_ptr->channels++;
+   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
+
+   /* Check for potential overflow */
+   if (width > (PNG_UINT_32_MAX
+                 >> 3)      /* 8-byte RGBA pixels */
+                 - 64       /* bigrowbuf hack */
+                 - 1        /* filter byte */
+                 - 7*8      /* rounding of width to multiple of 8 pixels */
+                 - 8)       /* extra max_pixel_depth pad */
+      info_ptr->rowbytes = 0;
+   else
+      info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
+}
+
+#ifdef PNG_oFFs_SUPPORTED
+void PNGAPI
+png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
+   png_int_32 offset_x, png_int_32 offset_y, int unit_type)
+{
+   png_debug1(1, "in %s storage function", "oFFs");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->x_offset = offset_x;
+   info_ptr->y_offset = offset_y;
+   info_ptr->offset_unit_type = (png_byte)unit_type;
+   info_ptr->valid |= PNG_INFO_oFFs;
+}
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+void PNGAPI
+png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
+   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
+   png_charp units, png_charpp params)
+{
+   png_size_t length;
+   int i;
+
+   png_debug1(1, "in %s storage function", "pCAL");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   length = png_strlen(purpose) + 1;
+   png_debug1(3, "allocating purpose for info (%lu bytes)",
+     (unsigned long)length);
+   info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
+   if (info_ptr->pcal_purpose == NULL)
+   {
+      png_warning(png_ptr, "Insufficient memory for pCAL purpose");
+      return;
+   }
+   png_memcpy(info_ptr->pcal_purpose, purpose, length);
+
+   png_debug(3, "storing X0, X1, type, and nparams in info");
+   info_ptr->pcal_X0 = X0;
+   info_ptr->pcal_X1 = X1;
+   info_ptr->pcal_type = (png_byte)type;
+   info_ptr->pcal_nparams = (png_byte)nparams;
+
+   length = png_strlen(units) + 1;
+   png_debug1(3, "allocating units for info (%lu bytes)",
+     (unsigned long)length);
+   info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
+   if (info_ptr->pcal_units == NULL)
+   {
+      png_warning(png_ptr, "Insufficient memory for pCAL units");
+      return;
+   }
+   png_memcpy(info_ptr->pcal_units, units, length);
+
+   info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
+      (png_size_t)((nparams + 1) * png_sizeof(png_charp)));
+   if (info_ptr->pcal_params == NULL)
+   {
+      png_warning(png_ptr, "Insufficient memory for pCAL params");
+      return;
+   }
+
+   png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));
+
+   for (i = 0; i < nparams; i++)
+   {
+      length = png_strlen(params[i]) + 1;
+      png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,
+        (unsigned long)length);
+      info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
+      if (info_ptr->pcal_params[i] == NULL)
+      {
+         png_warning(png_ptr, "Insufficient memory for pCAL parameter");
+         return;
+      }
+      png_memcpy(info_ptr->pcal_params[i], params[i], length);
+   }
+
+   info_ptr->valid |= PNG_INFO_pCAL;
+   info_ptr->free_me |= PNG_FREE_PCAL;
+}
+#endif
+
+#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void PNGAPI
+png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
+             int unit, double width, double height)
+{
+   png_debug1(1, "in %s storage function", "sCAL");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->scal_unit = (png_byte)unit;
+   info_ptr->scal_pixel_width = width;
+   info_ptr->scal_pixel_height = height;
+
+   info_ptr->valid |= PNG_INFO_sCAL;
+}
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void PNGAPI
+png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
+             int unit, png_charp swidth, png_charp sheight)
+{
+   png_size_t length;
+
+   png_debug1(1, "in %s storage function", "sCAL");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->scal_unit = (png_byte)unit;
+
+   length = png_strlen(swidth) + 1;
+   png_debug1(3, "allocating unit for info (%u bytes)",
+      (unsigned int)length);
+   info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
+   if (info_ptr->scal_s_width == NULL)
+   {
+      png_warning(png_ptr,
+         "Memory allocation failed while processing sCAL");
+      return;
+   }
+   png_memcpy(info_ptr->scal_s_width, swidth, length);
+
+   length = png_strlen(sheight) + 1;
+   png_debug1(3, "allocating unit for info (%u bytes)",
+      (unsigned int)length);
+   info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
+   if (info_ptr->scal_s_height == NULL)
+   {
+      png_free (png_ptr, info_ptr->scal_s_width);
+      info_ptr->scal_s_width = NULL;
+      png_warning(png_ptr,
+         "Memory allocation failed while processing sCAL");
+      return;
+   }
+   png_memcpy(info_ptr->scal_s_height, sheight, length);
+   info_ptr->valid |= PNG_INFO_sCAL;
+   info_ptr->free_me |= PNG_FREE_SCAL;
+}
+#endif
+#endif
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+void PNGAPI
+png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
+   png_uint_32 res_x, png_uint_32 res_y, int unit_type)
+{
+   png_debug1(1, "in %s storage function", "pHYs");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->x_pixels_per_unit = res_x;
+   info_ptr->y_pixels_per_unit = res_y;
+   info_ptr->phys_unit_type = (png_byte)unit_type;
+   info_ptr->valid |= PNG_INFO_pHYs;
+}
+#endif
+
+void PNGAPI
+png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
+   png_colorp palette, int num_palette)
+{
+
+   png_debug1(1, "in %s storage function", "PLTE");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
+   {
+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+         png_error(png_ptr, "Invalid palette length");
+      else
+      {
+         png_warning(png_ptr, "Invalid palette length");
+         return;
+      }
+   }
+
+   /* It may not actually be necessary to set png_ptr->palette here;
+    * we do it for backward compatibility with the way the png_handle_tRNS
+    * function used to do the allocation.
+    */
+   png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
+
+   /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
+    * of num_palette entries, in case of an invalid PNG file that has
+    * too-large sample values.
+    */
+   png_ptr->palette = (png_colorp)png_calloc(png_ptr,
+      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
+   png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
+   info_ptr->palette = png_ptr->palette;
+   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
+
+   info_ptr->free_me |= PNG_FREE_PLTE;
+
+   info_ptr->valid |= PNG_INFO_PLTE;
+}
+
+#ifdef PNG_sBIT_SUPPORTED
+void PNGAPI
+png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
+   png_color_8p sig_bit)
+{
+   png_debug1(1, "in %s storage function", "sBIT");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
+   info_ptr->valid |= PNG_INFO_sBIT;
+}
+#endif
+
+#ifdef PNG_sRGB_SUPPORTED
+void PNGAPI
+png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
+{
+   png_debug1(1, "in %s storage function", "sRGB");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   info_ptr->srgb_intent = (png_byte)intent;
+   info_ptr->valid |= PNG_INFO_sRGB;
+}
+
+void PNGAPI
+png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
+   int intent)
+{
+#ifdef PNG_gAMA_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   float file_gamma;
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   png_fixed_point int_file_gamma;
+#endif
+#endif
+#ifdef PNG_cHRM_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
+#endif
+   png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
+      int_green_y, int_blue_x, int_blue_y;
+#endif
+   png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_set_sRGB(png_ptr, info_ptr, intent);
+
+#ifdef PNG_gAMA_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   file_gamma = (float).45455;
+   png_set_gAMA(png_ptr, info_ptr, file_gamma);
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   int_file_gamma = 45455L;
+   png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
+#endif
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+   int_white_x = 31270L;
+   int_white_y = 32900L;
+   int_red_x   = 64000L;
+   int_red_y   = 33000L;
+   int_green_x = 30000L;
+   int_green_y = 60000L;
+   int_blue_x  = 15000L;
+   int_blue_y  =  6000L;
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   white_x = (float).3127;
+   white_y = (float).3290;
+   red_x   = (float).64;
+   red_y   = (float).33;
+   green_x = (float).30;
+   green_y = (float).60;
+   blue_x  = (float).15;
+   blue_y  = (float).06;
+#endif
+
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   png_set_cHRM_fixed(png_ptr, info_ptr,
+       int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
+       int_green_y, int_blue_x, int_blue_y);
+#endif
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   png_set_cHRM(png_ptr, info_ptr,
+       white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+#endif
+#endif /* cHRM */
+}
+#endif /* sRGB */
+
+
+#ifdef PNG_iCCP_SUPPORTED
+void PNGAPI
+png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
+             png_charp name, int compression_type,
+             png_charp profile, png_uint_32 proflen)
+{
+   png_charp new_iccp_name;
+   png_charp new_iccp_profile;
+   png_uint_32 length;
+
+   png_debug1(1, "in %s storage function", "iCCP");
+
+   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
+      return;
+
+   length = png_strlen(name)+1;
+   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
+   if (new_iccp_name == NULL)
+   {
+        png_warning(png_ptr, "Insufficient memory to process iCCP chunk");
+      return;
+   }
+   png_memcpy(new_iccp_name, name, length);
+   new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
+   if (new_iccp_profile == NULL)
+   {
+      png_free (png_ptr, new_iccp_name);
+      png_warning(png_ptr,
+          "Insufficient memory to process iCCP profile");
+      return;
+   }
+   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
+
+   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
+
+   info_ptr->iccp_proflen = proflen;
+   info_ptr->iccp_name = new_iccp_name;
+   info_ptr->iccp_profile = new_iccp_profile;
+   /* Compression is always zero but is here so the API and info structure
+    * does not have to change if we introduce multiple compression types
+    */
+   info_ptr->iccp_compression = (png_byte)compression_type;
+   info_ptr->free_me |= PNG_FREE_ICCP;
+   info_ptr->valid |= PNG_INFO_iCCP;
+}
+#endif
+
+#ifdef PNG_TEXT_SUPPORTED
+void PNGAPI
+png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
+             int num_text)
+{
+   int ret;
+   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
+   if (ret)
+      png_error(png_ptr, "Insufficient memory to store text");
+}
+
+int /* PRIVATE */
+png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
+               int num_text)
+{
+   int i;
+
+   png_debug1(1, "in %s storage function", ((png_ptr == NULL ||
+      png_ptr->chunk_name[0] == '\0') ?
+      "text" : (png_const_charp)png_ptr->chunk_name));
+
+   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
+      return(0);
+
+   /* Make sure we have enough space in the "text" array in info_struct
+    * to hold all of the incoming text_ptr objects.
+    */
+   if (info_ptr->num_text + num_text > info_ptr->max_text)
+   {
+      if (info_ptr->text != NULL)
+      {
+         png_textp old_text;
+         int old_max;
+
+         old_max = info_ptr->max_text;
+         info_ptr->max_text = info_ptr->num_text + num_text + 8;
+         old_text = info_ptr->text;
+         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
+            (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
+         if (info_ptr->text == NULL)
+         {
+            png_free(png_ptr, old_text);
+            return(1);
+         }
+         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
+            png_sizeof(png_text)));
+         png_free(png_ptr, old_text);
+      }
+      else
+      {
+         info_ptr->max_text = num_text + 8;
+         info_ptr->num_text = 0;
+         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
+            (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
+         if (info_ptr->text == NULL)
+            return(1);
+         info_ptr->free_me |= PNG_FREE_TEXT;
+      }
+      png_debug1(3, "allocated %d entries for info_ptr->text",
+         info_ptr->max_text);
+   }
+   for (i = 0; i < num_text; i++)
+   {
+      png_size_t text_length, key_len;
+      png_size_t lang_len, lang_key_len;
+      png_textp textp = &(info_ptr->text[info_ptr->num_text]);
+
+      if (text_ptr[i].key == NULL)
+          continue;
+
+      key_len = png_strlen(text_ptr[i].key);
+
+      if (text_ptr[i].compression <= 0)
+      {
+         lang_len = 0;
+         lang_key_len = 0;
+      }
+
+      else
+#ifdef PNG_iTXt_SUPPORTED
+      {
+         /* Set iTXt data */
+
+         if (text_ptr[i].lang != NULL)
+            lang_len = png_strlen(text_ptr[i].lang);
+         else
+            lang_len = 0;
+         if (text_ptr[i].lang_key != NULL)
+            lang_key_len = png_strlen(text_ptr[i].lang_key);
+         else
+            lang_key_len = 0;
+      }
+#else /* PNG_iTXt_SUPPORTED */
+      {
+         png_warning(png_ptr, "iTXt chunk not supported");
+         continue;
+      }
+#endif
+
+      if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
+      {
+         text_length = 0;
+#ifdef PNG_iTXt_SUPPORTED
+         if (text_ptr[i].compression > 0)
+            textp->compression = PNG_ITXT_COMPRESSION_NONE;
+         else
+#endif
+            textp->compression = PNG_TEXT_COMPRESSION_NONE;
+      }
+
+      else
+      {
+         text_length = png_strlen(text_ptr[i].text);
+         textp->compression = text_ptr[i].compression;
+      }
+
+      textp->key = (png_charp)png_malloc_warn(png_ptr,
+         (png_size_t)
+         (key_len + text_length + lang_len + lang_key_len + 4));
+      if (textp->key == NULL)
+         return(1);
+      png_debug2(2, "Allocated %lu bytes at %x in png_set_text",
+                 (unsigned long)(png_uint_32)
+                 (key_len + lang_len + lang_key_len + text_length + 4),
+                 (int)textp->key);
+
+      png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
+      *(textp->key + key_len) = '\0';
+#ifdef PNG_iTXt_SUPPORTED
+      if (text_ptr[i].compression > 0)
+      {
+         textp->lang = textp->key + key_len + 1;
+         png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
+         *(textp->lang + lang_len) = '\0';
+         textp->lang_key = textp->lang + lang_len + 1;
+         png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
+         *(textp->lang_key + lang_key_len) = '\0';
+         textp->text = textp->lang_key + lang_key_len + 1;
+      }
+      else
+#endif
+      {
+#ifdef PNG_iTXt_SUPPORTED
+         textp->lang=NULL;
+         textp->lang_key=NULL;
+#endif
+         textp->text = textp->key + key_len + 1;
+      }
+      if (text_length)
+         png_memcpy(textp->text, text_ptr[i].text,
+            (png_size_t)(text_length));
+      *(textp->text + text_length) = '\0';
+
+#ifdef PNG_iTXt_SUPPORTED
+      if (textp->compression > 0)
+      {
+         textp->text_length = 0;
+         textp->itxt_length = text_length;
+      }
+      else
+#endif
+
+      {
+         textp->text_length = text_length;
+#ifdef PNG_iTXt_SUPPORTED
+         textp->itxt_length = 0;
+#endif
+      }
+      info_ptr->num_text++;
+      png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
+   }
+   return(0);
+}
+#endif
+
+#ifdef PNG_tIME_SUPPORTED
+void PNGAPI
+png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
+{
+   png_debug1(1, "in %s storage function", "tIME");
+
+   if (png_ptr == NULL || info_ptr == NULL ||
+       (png_ptr->mode & PNG_WROTE_tIME))
+      return;
+
+   png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
+   info_ptr->valid |= PNG_INFO_tIME;
+}
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+void PNGAPI
+png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
+   png_bytep trans_alpha, int num_trans, png_color_16p trans_color)
+{
+   png_debug1(1, "in %s storage function", "tRNS");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   if (trans_alpha != NULL)
+   {
+       /* It may not actually be necessary to set png_ptr->trans_alpha here;
+        * we do it for backward compatibility with the way the png_handle_tRNS
+        * function used to do the allocation.
+        */
+
+       png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
+
+       /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
+       png_ptr->trans_alpha = info_ptr->trans_alpha = (png_bytep)png_malloc(png_ptr,
+           (png_size_t)PNG_MAX_PALETTE_LENGTH);
+       if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
+          png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
+   }
+
+   if (trans_color != NULL)
+   {
+      int sample_max = (1 << info_ptr->bit_depth);
+      if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
+          (int)trans_color->gray > sample_max) ||
+          (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
+          ((int)trans_color->red > sample_max ||
+          (int)trans_color->green > sample_max ||
+          (int)trans_color->blue > sample_max)))
+         png_warning(png_ptr,
+            "tRNS chunk has out-of-range samples for bit_depth");
+      png_memcpy(&(info_ptr->trans_color), trans_color,
+         png_sizeof(png_color_16));
+      if (num_trans == 0)
+         num_trans = 1;
+   }
+
+   info_ptr->num_trans = (png_uint_16)num_trans;
+   if (num_trans != 0)
+   {
+      info_ptr->valid |= PNG_INFO_tRNS;
+      info_ptr->free_me |= PNG_FREE_TRNS;
+   }
+}
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+void PNGAPI
+png_set_sPLT(png_structp png_ptr,
+             png_infop info_ptr, png_sPLT_tp entries, int nentries)
+/*
+ *  entries        - array of png_sPLT_t structures
+ *                   to be added to the list of palettes
+ *                   in the info structure.
+ *  nentries       - number of palette structures to be
+ *                   added.
+ */
+{
+   png_sPLT_tp np;
+   int i;
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   np = (png_sPLT_tp)png_malloc_warn(png_ptr,
+       (info_ptr->splt_palettes_num + nentries) *
+        (png_size_t)png_sizeof(png_sPLT_t));
+   if (np == NULL)
+   {
+      png_warning(png_ptr, "No memory for sPLT palettes");
+      return;
+   }
+
+   png_memcpy(np, info_ptr->splt_palettes,
+       info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
+   png_free(png_ptr, info_ptr->splt_palettes);
+   info_ptr->splt_palettes=NULL;
+
+   for (i = 0; i < nentries; i++)
+   {
+      png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
+      png_sPLT_tp from = entries + i;
+      png_uint_32 length;
+
+      length = png_strlen(from->name) + 1;
+      to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)length);
+      if (to->name == NULL)
+      {
+         png_warning(png_ptr,
+           "Out of memory while processing sPLT chunk");
+         continue;
+      }
+      png_memcpy(to->name, from->name, length);
+      to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
+          (png_size_t)(from->nentries * png_sizeof(png_sPLT_entry)));
+      if (to->entries == NULL)
+      {
+         png_warning(png_ptr,
+           "Out of memory while processing sPLT chunk");
+         png_free(png_ptr, to->name);
+         to->name = NULL;
+         continue;
+      }
+      png_memcpy(to->entries, from->entries,
+          from->nentries * png_sizeof(png_sPLT_entry));
+      to->nentries = from->nentries;
+      to->depth = from->depth;
+   }
+
+   info_ptr->splt_palettes = np;
+   info_ptr->splt_palettes_num += nentries;
+   info_ptr->valid |= PNG_INFO_sPLT;
+   info_ptr->free_me |= PNG_FREE_SPLT;
+}
+#endif /* PNG_sPLT_SUPPORTED */
+
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+void PNGAPI
+png_set_unknown_chunks(png_structp png_ptr,
+   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
+{
+   png_unknown_chunkp np;
+   int i;
+
+   if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
+      return;
+
+   np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
+       (png_size_t)((info_ptr->unknown_chunks_num + num_unknowns) *
+       png_sizeof(png_unknown_chunk)));
+   if (np == NULL)
+   {
+      png_warning(png_ptr,
+          "Out of memory while processing unknown chunk");
+      return;
+   }
+
+   png_memcpy(np, info_ptr->unknown_chunks,
+       info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
+   png_free(png_ptr, info_ptr->unknown_chunks);
+   info_ptr->unknown_chunks = NULL;
+
+   for (i = 0; i < num_unknowns; i++)
+   {
+      png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
+      png_unknown_chunkp from = unknowns + i;
+
+      png_memcpy((png_charp)to->name, (png_charp)from->name,
+          png_sizeof(from->name));
+      to->name[png_sizeof(to->name)-1] = '\0';
+      to->size = from->size;
+      /* Note our location in the read or write sequence */
+      to->location = (png_byte)(png_ptr->mode & 0xff);
+
+      if (from->size == 0)
+         to->data=NULL;
+      else
+      {
+         to->data = (png_bytep)png_malloc_warn(png_ptr,
+           (png_size_t)from->size);
+         if (to->data == NULL)
+         {
+            png_warning(png_ptr,
+             "Out of memory while processing unknown chunk");
+            to->size = 0;
+         }
+         else
+            png_memcpy(to->data, from->data, from->size);
+      }
+   }
+
+   info_ptr->unknown_chunks = np;
+   info_ptr->unknown_chunks_num += num_unknowns;
+   info_ptr->free_me |= PNG_FREE_UNKN;
+}
+void PNGAPI
+png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
+   int chunk, int location)
+{
+   if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
+       (int)info_ptr->unknown_chunks_num)
+      info_ptr->unknown_chunks[chunk].location = (png_byte)location;
+}
+#endif
+
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+png_uint_32 PNGAPI
+png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
+{
+   png_debug(1, "in png_permit_mng_features");
+
+   if (png_ptr == NULL)
+      return (png_uint_32)0;
+   png_ptr->mng_features_permitted =
+     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
+   return (png_uint_32)png_ptr->mng_features_permitted;
+}
+#endif
+
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+void PNGAPI
+png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
+   chunk_list, int num_chunks)
+{
+   png_bytep new_list, p;
+   int i, old_num_chunks;
+   if (png_ptr == NULL)
+      return;
+   if (num_chunks == 0)
+   {
+      if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
+         png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+      else
+         png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+
+      if (keep == PNG_HANDLE_CHUNK_ALWAYS)
+         png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+      else
+         png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+      return;
+   }
+   if (chunk_list == NULL)
+      return;
+   old_num_chunks = png_ptr->num_chunk_list;
+   new_list=(png_bytep)png_malloc(png_ptr,
+      (png_size_t)
+       (5*(num_chunks + old_num_chunks)));
+   if (png_ptr->chunk_list != NULL)
+   {
+      png_memcpy(new_list, png_ptr->chunk_list,
+          (png_size_t)(5*old_num_chunks));
+      png_free(png_ptr, png_ptr->chunk_list);
+      png_ptr->chunk_list=NULL;
+   }
+   png_memcpy(new_list + 5*old_num_chunks, chunk_list,
+       (png_size_t)(5*num_chunks));
+   for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
+      *p=(png_byte)keep;
+   png_ptr->num_chunk_list = old_num_chunks + num_chunks;
+   png_ptr->chunk_list = new_list;
+   png_ptr->free_me |= PNG_FREE_LIST;
+}
+#endif
+
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+void PNGAPI
+png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
+   png_user_chunk_ptr read_user_chunk_fn)
+{
+   png_debug(1, "in png_set_read_user_chunk_fn");
+
+   if (png_ptr == NULL)
+      return;
+
+   png_ptr->read_user_chunk_fn = read_user_chunk_fn;
+   png_ptr->user_chunk_ptr = user_chunk_ptr;
+}
+#endif
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+void PNGAPI
+png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
+{
+   png_debug1(1, "in %s storage function", "rows");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
+      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
+   info_ptr->row_pointers = row_pointers;
+   if (row_pointers)
+      info_ptr->valid |= PNG_INFO_IDAT;
+}
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+void PNGAPI
+png_set_compression_buffer_size(png_structp png_ptr,
+    png_size_t size)
+{
+    if (png_ptr == NULL)
+       return;
+    png_free(png_ptr, png_ptr->zbuf);
+    png_ptr->zbuf_size = size;
+    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
+    png_ptr->zstream.next_out = png_ptr->zbuf;
+    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+}
+#endif
+
+void PNGAPI
+png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
+{
+   if (png_ptr && info_ptr)
+      info_ptr->valid &= ~mask;
+}
+
+
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+/* This function was added to libpng 1.2.6 */
+void PNGAPI
+png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
+    png_uint_32 user_height_max)
+{
+   /* Images with dimensions larger than these limits will be
+    * rejected by png_set_IHDR().  To accept any PNG datastream
+    * regardless of dimensions, set both limits to 0x7ffffffL.
+    */
+   if (png_ptr == NULL)
+      return;
+   png_ptr->user_width_max = user_width_max;
+   png_ptr->user_height_max = user_height_max;
+}
+/* This function was added to libpng 1.4.0 */
+void PNGAPI
+png_set_chunk_cache_max (png_structp png_ptr,
+   png_uint_32 user_chunk_cache_max)
+{
+    if (png_ptr == NULL)
+      return;
+    png_ptr->user_chunk_cache_max = user_chunk_cache_max;
+    if (user_chunk_cache_max == 0x7fffffffL)  /* Unlimited */
+       png_ptr->user_chunk_cache_max = 0;
+    else
+       png_ptr->user_chunk_cache_max = user_chunk_cache_max + 1;
+}
+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
+
+
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+void PNGAPI
+png_set_benign_errors(png_structp png_ptr, int allowed)
+{
+   png_debug(1, "in png_set_benign_errors");
+
+   if (allowed)
+      png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
+   else
+      png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;
+}
+#endif /* PNG_BENIGN_ERRORS_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pngtest.c b/src/libpng/pngtest.c
index 8b2d194e1..4b70404c4 100644
--- a/src/libpng/pngtest.c
+++ b/src/libpng/pngtest.c
@@ -1,1693 +1,1630 @@
-

-/* pngtest.c - a simple test program to test libpng

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This program reads in a PNG image, writes it out again, and then

- * compares the two files.  If the files are identical, this shows that

- * the basic chunk handling, filtering, and (de)compression code is working

- * properly.  It does not currently test all of the transforms, although

- * it probably should.

- *

- * The program will report "FAIL" in certain legitimate cases:

- * 1) when the compression level or filter selection method is changed.

- * 2) when the maximum IDAT size (PNG_ZBUF_SIZE in pngconf.h) is not 8192.

- * 3) unknown unsafe-to-copy ancillary chunks or unknown critical chunks

- *    exist in the input file.

- * 4) others not listed here...

- * In these cases, it is best to check with another tool such as "pngcheck"

- * to see what the differences between the two files are.

- *

- * If a filename is given on the command-line, then this file is used

- * for the input, rather than the default "pngtest.png".  This allows

- * testing a wide variety of files easily.  You can also test a number

- * of files at once by typing "pngtest -m file1.png file2.png ..."

- */

-

-#define PNG_PEDANTIC_WARNINGS

-#include "png.h"

-

-#ifdef _WIN32_WCE

-#  if _WIN32_WCE < 211

-     __error__ (f|w)printf functions are not supported on old WindowsCE.;

-#  endif

-#  include <windows.h>

-#  include <stdlib.h>

-#  define READFILE(file, data, length, check) \

-     if (ReadFile(file, data, length, &check, NULL)) check = 0

-#  define WRITEFILE(file, data, length, check)) \

-     if (WriteFile(file, data, length, &check, NULL)) check = 0

-#  define FCLOSE(file) CloseHandle(file)

-#else

-#  include <stdio.h>

-#  include <stdlib.h>

-#  define READFILE(file, data, length, check) \

-     check=(png_size_t)fread(data, (png_size_t)1, length, file)

-#  define WRITEFILE(file, data, length, check) \

-     check=(png_size_t)fwrite(data, (png_size_t)1, length, file)

-#  define FCLOSE(file) fclose(file)

-#endif

-

-#ifndef PNG_STDIO_SUPPORTED

-#  ifdef _WIN32_WCE

-     typedef HANDLE                png_FILE_p;

-#  else

-     typedef FILE                * png_FILE_p;

-#  endif

-#endif

-

-/* Makes pngtest verbose so we can find problems (needs to be before png.h) */

-#ifndef PNG_DEBUG

-#  define PNG_DEBUG 0

-#endif

-

-#if !PNG_DEBUG

-#  define SINGLE_ROWBUF_ALLOC  /* Makes buffer overruns easier to nail */

-#endif

-

-/* Turn on CPU timing

-#define PNGTEST_TIMING

-*/

-

-#ifndef PNG_FLOATING_POINT_SUPPORTED

-#undef PNGTEST_TIMING

-#endif

-

-#ifdef PNGTEST_TIMING

-static float t_start, t_stop, t_decode, t_encode, t_misc;

-#include <time.h>

-#endif

-

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-#define PNG_tIME_STRING_LENGTH 29

-static int tIME_chunk_present = 0;

-static char tIME_string[PNG_tIME_STRING_LENGTH] = "tIME chunk is not present";

-#endif

-

-static int verbose = 0;

-

-int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));

-

-#ifdef __TURBOC__

-#include <mem.h>

-#endif

-

-/* Defined so I can write to a file on gui/windowing platforms */

-/*  #define STDERR stderr  */

-#define STDERR stdout   /* For DOS */

-

-/* In case a system header (e.g., on AIX) defined jmpbuf */

-#ifdef jmpbuf

-#  undef jmpbuf

-#endif

-

-/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */

-#ifndef png_jmpbuf

-#  define png_jmpbuf(png_ptr) png_ptr->jmpbuf

-#endif

-

-/* Example of using row callbacks to make a simple progress meter */

-static int status_pass = 1;

-static int status_dots_requested = 0;

-static int status_dots = 1;

-

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

-read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

-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 (status_pass != pass)

-   {

-      fprintf(stdout, "\n Pass %d: ", pass);

-      status_pass = pass;

-      status_dots = 31;

-   }

-   status_dots--;

-   if (status_dots == 0)

-   {

-      fprintf(stdout, "\n         ");

-      status_dots=30;

-   }

-   fprintf(stdout, "r");

-}

-

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

-write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

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

-   fprintf(stdout, "w");

-}

-

-

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-/* Example of using user transform callback (we don't transform anything,

- * but merely examine the row filters.  We set this to 256 rather than

- * 5 in case illegal filter values are present.)

- */

-static png_uint_32 filters_used[256];

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

-count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data);

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

-count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)

-{

-   if (png_ptr != NULL && row_info != NULL)

-      ++filters_used[*(data - 1)];

-}

-#endif

-

-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-/* Example of using user transform callback (we don't transform anything,

- * but merely count the zero samples)

- */

-

-static png_uint_32 zero_samples;

-

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

-count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data);

-void

-#ifdef PNG_1_0_X

-PNGAPI

-#endif

-count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)

-{

-   png_bytep dp = data;

-   if (png_ptr == NULL)return;

-

-   /* Contents of row_info:

-    *  png_uint_32 width      width of row

-    *  png_uint_32 rowbytes   number of bytes in row

-    *  png_byte color_type    color type of pixels

-    *  png_byte bit_depth     bit depth of samples

-    *  png_byte channels      number of channels (1-4)

-    *  png_byte pixel_depth   bits per pixel (depth*channels)

-    */

-

-    /* 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)

-    {

-       int pos = 0;

-       png_uint_32 n, nstop;

-       for (n = 0, nstop=row_info->width; n<nstop; n++)

-       {

-          if (row_info->bit_depth == 1)

-          {

-             if (((*dp << pos++ ) & 0x80) == 0)

-                zero_samples++;

-             if (pos == 8)

-             {

-                pos = 0;

-                dp++;

-             }

-          }

-          if (row_info->bit_depth == 2)

-          {

-             if (((*dp << (pos+=2)) & 0xc0) == 0)

-                zero_samples++;

-             if (pos == 8)

-             {

-                pos = 0;

-                dp++;

-             }

-          }

-          if (row_info->bit_depth == 4)

-          {

-             if (((*dp << (pos+=4)) & 0xf0) == 0)

-                zero_samples++;

-             if (pos == 8)

-             {

-                pos = 0;

-                dp++;

-             }

-          }

-          if (row_info->bit_depth == 8)

-             if (*dp++ == 0)

-                zero_samples++;

-          if (row_info->bit_depth == 16)

-          {

-             if ((*dp | *(dp+1)) == 0)

-                zero_samples++;

-             dp+=2;

-          }

-       }

-    }

-    else /* Other color types */

-    {

-       png_uint_32 n, nstop;

-       int channel;

-       int color_channels = row_info->channels;

-       if (row_info->color_type > 3)color_channels--;

-

-       for (n = 0, nstop=row_info->width; n<nstop; n++)

-       {

-          for (channel = 0; channel < color_channels; channel++)

-          {

-             if (row_info->bit_depth == 8)

-                if (*dp++ == 0)

-                   zero_samples++;

-             if (row_info->bit_depth == 16)

-             {

-                if ((*dp | *(dp+1)) == 0)

-                   zero_samples++;

-                dp+=2;

-             }

-          }

-          if (row_info->color_type > 3)

-          {

-             dp++;

-             if (row_info->bit_depth == 16)

-                dp++;

-          }

-       }

-    }

-}

-#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */

-

-static int wrote_question = 0;

-

-#ifndef PNG_STDIO_SUPPORTED

-/* START of code to validate stdio-free compilation */

-/* 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.

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

- * read_data function and use it at run time with png_set_read_fn(), rather

- * than changing the library.

- */

-

-#ifndef USE_FAR_KEYWORD

-static void

-pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   png_size_t check;

-

-   /* 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.

-    */

-   READFILE((png_FILE_p)png_ptr->io_ptr, data, length, check);

-

-   if (check != length)

-   {

-      png_error(png_ptr, "Read Error!");

-   }

-}

-#else

-/* This is the model-independent version. Since the standard I/O library

-   can't handle far buffers in the medium and small models, we have to copy

-   the data.

-*/

-

-#define NEAR_BUF_SIZE 1024

-#define MIN(a,b) (a <= b ? a : b)

-

-static void

-pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   int check;

-   png_byte *n_data;

-   png_FILE_p io_ptr;

-

-   /* Check if data really is near. If so, use usual code. */

-   n_data = (png_byte *)CVT_PTR_NOCHECK(data);

-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

-   if ((png_bytep)n_data == data)

-   {

-      READFILE(io_ptr, n_data, length, check);

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t read, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         read = MIN(NEAR_BUF_SIZE, remaining);

-         READFILE(io_ptr, buf, 1, err);

-         png_memcpy(data, buf, read); /* Copy far buffer to near buffer */

-         if (err != read)

-            break;

-         else

-            check += err;

-         data += read;

-         remaining -= read;

-      }

-      while (remaining != 0);

-   }

-   if (check != length)

-      png_error(png_ptr, "read Error");

-}

-#endif /* USE_FAR_KEYWORD */

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-static void

-pngtest_flush(png_structp png_ptr)

-{

-   /* Do nothing; fflush() is said to be just a waste of energy. */

-   png_ptr = png_ptr;  /* Stifle compiler warning */

-}

-#endif

-

-/* 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

- * write_data function and use it at run time with png_set_write_fn(), rather

- * than changing the library.

- */

-#ifndef USE_FAR_KEYWORD

-static void

-pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   png_uint_32 check;

-

-   WRITEFILE((png_FILE_p)png_ptr->io_ptr,  data, length, check);

-   if (check != length)

-   {

-      png_error(png_ptr, "Write Error");

-   }

-}

-#else

-/* This is the model-independent version. Since the standard I/O library

-   can't handle far buffers in the medium and small models, we have to copy

-   the data.

-*/

-

-#define NEAR_BUF_SIZE 1024

-#define MIN(a,b) (a <= b ? a : b)

-

-static void

-pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   png_uint_32 check;

-   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

-   png_FILE_p io_ptr;

-

-   /* Check if data really is near. If so, use usual code. */

-   near_data = (png_byte *)CVT_PTR_NOCHECK(data);

-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

-   if ((png_bytep)near_data == data)

-   {

-      WRITEFILE(io_ptr, near_data, length, check);

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t written, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         written = MIN(NEAR_BUF_SIZE, remaining);

-         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */

-         WRITEFILE(io_ptr, buf, written, err);

-         if (err != written)

-            break;

-         else

-            check += err;

-         data += written;

-         remaining -= written;

-      }

-      while (remaining != 0);

-   }

-   if (check != length)

-   {

-      png_error(png_ptr, "Write Error");

-   }

-}

-#endif /* USE_FAR_KEYWORD */

-

-/* This function is called when there is a warning, but the library thinks

- * it can continue anyway.  Replacement functions don't have to do anything

- * here if you don't want to.  In the default configuration, png_ptr is

- * not used, but it is passed in case it may be useful.

- */

-static void

-pngtest_warning(png_structp png_ptr, png_const_charp message)

-{

-   PNG_CONST char *name = "UNKNOWN (ERROR!)";

-   if (png_ptr != NULL && png_ptr->error_ptr != NULL)

-      name = png_ptr->error_ptr;

-   fprintf(STDERR, "%s: libpng warning: %s\n", name, message);

-}

-

-/* This is the default error handling function.  Note that replacements for

- * this function MUST NOT RETURN, or the program will likely crash.  This

- * function is used by default, or if the program supplies NULL for the

- * error function pointer in png_set_error_fn().

- */

-static void

-pngtest_error(png_structp png_ptr, png_const_charp message)

-{

-   pngtest_warning(png_ptr, message);

-   /* We can return because png_error calls the default handler, which is

-    * actually OK in this case.

-    */

-}

-#endif /* !PNG_STDIO_SUPPORTED */

-/* END of code to validate stdio-free compilation */

-

-/* START of code to validate memory allocation and deallocation */

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-

-/* Allocate memory.  For reasonable files, size should never exceed

- * 64K.  However, zlib may allocate more then 64K if you don't tell

- * it not to.  See zconf.h and png.h for more information.  zlib does

- * need to allocate exactly 64K, so whatever you call here must

- * have the ability to do that.

- *

- * 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.

- */

-typedef struct memory_information

-{

-   png_uint_32               size;

-   png_voidp                 pointer;

-   struct memory_information FAR *next;

-} memory_information;

-typedef memory_information FAR *memory_infop;

-

-static memory_infop pinformation = NULL;

-static int current_allocation = 0;

-static int maximum_allocation = 0;

-static int total_allocation = 0;

-static int num_allocations = 0;

-

-png_voidp png_debug_malloc PNGARG((png_structp png_ptr, png_uint_32 size));

-void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr));

-

-png_voidp

-png_debug_malloc(png_structp png_ptr, png_uint_32 size)

-{

-

-   /* png_malloc has already tested for NULL; png_create_struct calls

-    * png_debug_malloc directly, with png_ptr == NULL which is OK

-    */

-

-   if (size == 0)

-      return (NULL);

-

-   /* This calls the library allocator twice, once to get the requested

-      buffer and once to get a new free list entry. */

-   {

-      /* Disable malloc_fn and free_fn */

-      memory_infop pinfo;

-      png_set_mem_fn(png_ptr, NULL, NULL, NULL);

-      pinfo = (memory_infop)png_malloc(png_ptr,

-         (png_uint_32)png_sizeof(*pinfo));

-      pinfo->size = size;

-      current_allocation += size;

-      total_allocation += size;

-      num_allocations ++;

-      if (current_allocation > maximum_allocation)

-         maximum_allocation = current_allocation;

-      pinfo->pointer = (png_voidp)png_malloc(png_ptr, size);

-      /* Restore malloc_fn and free_fn */

-      png_set_mem_fn(png_ptr,

-          png_voidp_NULL, (png_malloc_ptr)png_debug_malloc,

-          (png_free_ptr)png_debug_free);

-      if (size != 0 && pinfo->pointer == NULL)

-      {

-         current_allocation -= size;

-         total_allocation -= size;

-         png_error(png_ptr,

-           "out of memory in pngtest->png_debug_malloc.");

-      }

-      pinfo->next = pinformation;

-      pinformation = pinfo;

-      /* Make sure the caller isn't assuming zeroed memory. */

-      png_memset(pinfo->pointer, 0xdd, pinfo->size);

-      if (verbose)

-         printf("png_malloc %lu bytes at %x\n", (unsigned long)size,

-            pinfo->pointer);

-      return (png_voidp)(pinfo->pointer);

-   }

-}

-

-/* Free a pointer.  It is removed from the list at the same time. */

-void

-png_debug_free(png_structp png_ptr, png_voidp ptr)

-{

-   if (png_ptr == NULL)

-      fprintf(STDERR, "NULL pointer to png_debug_free.\n");

-   if (ptr == 0)

-   {

-#if 0 /* This happens all the time. */

-      fprintf(STDERR, "WARNING: freeing NULL pointer\n");

-#endif

-      return;

-   }

-

-   /* Unlink the element from the list. */

-   {

-      memory_infop FAR *ppinfo = &pinformation;

-      for (;;)

-      {

-         memory_infop pinfo = *ppinfo;

-         if (pinfo->pointer == ptr)

-         {

-            *ppinfo = pinfo->next;

-            current_allocation -= pinfo->size;

-            if (current_allocation < 0)

-               fprintf(STDERR, "Duplicate free of memory\n");

-            /* We must free the list element too, but first kill

-               the memory that is to be freed. */

-            png_memset(ptr, 0x55, pinfo->size);

-            png_free_default(png_ptr, pinfo);

-            pinfo = NULL;

-            break;

-         }

-         if (pinfo->next == NULL)

-         {

-            fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);

-            break;

-         }

-         ppinfo = &pinfo->next;

-      }

-   }

-

-   /* Finally free the data. */

-   if (verbose)

-      printf("Freeing %x\n", ptr);

-   png_free_default(png_ptr, ptr);

-   ptr = NULL;

-}

-#endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */

-/* END of code to test memory allocation/deallocation */

-

-

-/* Demonstration of user chunk support of the sTER and vpAg chunks */

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-

-/* (sTER is a public chunk not yet known by libpng.  vpAg is a private

-chunk used in ImageMagick to store "virtual page" size).  */

-

-static png_uint_32 user_chunk_data[4];

-

-    /* 0: sTER mode + 1

-     * 1: vpAg width

-     * 2: vpAg height

-     * 3: vpAg units

-     */

-

-static int read_user_chunk_callback(png_struct *png_ptr,

-   png_unknown_chunkp chunk)

-{

-   png_uint_32

-     *my_user_chunk_data;

-

-   /* Return one of the following:

-    *    return (-n);  chunk had an error

-    *    return (0);  did not recognize

-    *    return (n);  success

-    *

-    * The unknown chunk structure contains the chunk data:

-    * png_byte name[5];

-    * png_byte *data;

-    * png_size_t size;

-    *

-    * Note that libpng has already taken care of the CRC handling.

-    */

-

-   if (chunk->name[0] == 115 && chunk->name[1] ==  84 &&     /* s  T */

-       chunk->name[2] ==  69 && chunk->name[3] ==  82)       /* E  R */

-      {

-         /* Found sTER chunk */

-         if (chunk->size != 1)

-            return (-1); /* Error return */

-         if (chunk->data[0] != 0 && chunk->data[0] != 1)

-            return (-1);  /* Invalid mode */

-         my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);

-         my_user_chunk_data[0]=chunk->data[0]+1;

-         return (1);

-      }

-

-   if (chunk->name[0] != 118 || chunk->name[1] != 112 ||    /* v  p */

-       chunk->name[2] !=  65 || chunk->name[3] != 103)      /* A  g */

-      return (0); /* Did not recognize */

-

-   /* Found ImageMagick vpAg chunk */

-

-   if (chunk->size != 9)

-      return (-1); /* Error return */

-

-   my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);

-

-   my_user_chunk_data[1]=png_get_uint_31(png_ptr, chunk->data);

-   my_user_chunk_data[2]=png_get_uint_31(png_ptr, chunk->data + 4);

-   my_user_chunk_data[3]=(png_uint_32)chunk->data[8];

-

-   return (1);

-

-}

-#endif

-/* END of code to demonstrate user chunk support */

-

-/* Test one file */

-int

-test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)

-{

-   static png_FILE_p fpin;

-   static png_FILE_p fpout;  /* "static" prevents setjmp corruption */

-   png_structp read_ptr;

-   png_infop read_info_ptr, end_info_ptr;

-#ifdef PNG_WRITE_SUPPORTED

-   png_structp write_ptr;

-   png_infop write_info_ptr;

-   png_infop write_end_info_ptr;

-#else

-   png_structp write_ptr = NULL;

-   png_infop write_info_ptr = NULL;

-   png_infop write_end_info_ptr = NULL;

-#endif

-   png_bytep row_buf;

-   png_uint_32 y;

-   png_uint_32 width, height;

-   int num_pass, pass;

-   int bit_depth, color_type;

-#ifdef PNG_SETJMP_SUPPORTED

-#ifdef USE_FAR_KEYWORD

-   jmp_buf jmpbuf;

-#endif

-#endif

-

-#ifdef _WIN32_WCE

-   TCHAR path[MAX_PATH];

-#endif

-   char inbuf[256], outbuf[256];

-

-   row_buf = NULL;

-

-#ifdef _WIN32_WCE

-   MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);

-   if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)

-#else

-   if ((fpin = fopen(inname, "rb")) == NULL)

-#endif

-   {

-      fprintf(STDERR, "Could not find input file %s\n", inname);

-      return (1);

-   }

-

-#ifdef _WIN32_WCE

-   MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);

-   if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)

-#else

-   if ((fpout = fopen(outname, "wb")) == NULL)

-#endif

-   {

-      fprintf(STDERR, "Could not open output file %s\n", outname);

-      FCLOSE(fpin);

-      return (1);

-   }

-

-   png_debug(0, "Allocating read and write structures");

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-   read_ptr =

-      png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

-      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,

-      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

-#else

-   read_ptr =

-      png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

-      png_error_ptr_NULL, png_error_ptr_NULL);

-#endif

-#ifndef PNG_STDIO_SUPPORTED

-   png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,

-       pngtest_warning);

-#endif

-

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-   user_chunk_data[0] = 0;

-   user_chunk_data[1] = 0;

-   user_chunk_data[2] = 0;

-   user_chunk_data[3] = 0;

-   png_set_read_user_chunk_fn(read_ptr, user_chunk_data,

-     read_user_chunk_callback);

-

-#endif

-#ifdef PNG_WRITE_SUPPORTED

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-   write_ptr =

-      png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

-      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,

-      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

-#else

-   write_ptr =

-      png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

-      png_error_ptr_NULL, png_error_ptr_NULL);

-#endif

-#ifndef PNG_STDIO_SUPPORTED

-   png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,

-       pngtest_warning);

-#endif

-#endif

-   png_debug(0, "Allocating read_info, write_info and end_info structures");

-   read_info_ptr = png_create_info_struct(read_ptr);

-   end_info_ptr = png_create_info_struct(read_ptr);

-#ifdef PNG_WRITE_SUPPORTED

-   write_info_ptr = png_create_info_struct(write_ptr);

-   write_end_info_ptr = png_create_info_struct(write_ptr);

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-   png_debug(0, "Setting jmpbuf for read struct");

-#ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

-#else

-   if (setjmp(png_jmpbuf(read_ptr)))

-#endif

-   {

-      fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);

-      png_free(read_ptr, row_buf);

-      row_buf = NULL;

-      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

-#ifdef PNG_WRITE_SUPPORTED

-      png_destroy_info_struct(write_ptr, &write_end_info_ptr);

-      png_destroy_write_struct(&write_ptr, &write_info_ptr);

-#endif

-      FCLOSE(fpin);

-      FCLOSE(fpout);

-      return (1);

-   }

-#ifdef USE_FAR_KEYWORD

-   png_memcpy(png_jmpbuf(read_ptr), jmpbuf, png_sizeof(jmp_buf));

-#endif

-

-#ifdef PNG_WRITE_SUPPORTED

-   png_debug(0, "Setting jmpbuf for write struct");

-#ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

-#else

-   if (setjmp(png_jmpbuf(write_ptr)))

-#endif

-   {

-      fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);

-      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

-      png_destroy_info_struct(write_ptr, &write_end_info_ptr);

-#ifdef PNG_WRITE_SUPPORTED

-      png_destroy_write_struct(&write_ptr, &write_info_ptr);

-#endif

-      FCLOSE(fpin);

-      FCLOSE(fpout);

-      return (1);

-   }

-#ifdef USE_FAR_KEYWORD

-   png_memcpy(png_jmpbuf(write_ptr), jmpbuf, png_sizeof(jmp_buf));

-#endif

-#endif

-#endif

-

-   png_debug(0, "Initializing input and output streams");

-#ifdef PNG_STDIO_SUPPORTED

-   png_init_io(read_ptr, fpin);

-#  ifdef PNG_WRITE_SUPPORTED

-   png_init_io(write_ptr, fpout);

-#  endif

-#else

-   png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);

-#  ifdef PNG_WRITE_SUPPORTED

-   png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,

-#    ifdef PNG_WRITE_FLUSH_SUPPORTED

-      pngtest_flush);

-#    else

-      NULL);

-#    endif

-#  endif

-#endif

-   if (status_dots_requested == 1)

-   {

-#ifdef PNG_WRITE_SUPPORTED

-      png_set_write_status_fn(write_ptr, write_row_callback);

-#endif

-      png_set_read_status_fn(read_ptr, read_row_callback);

-   }

-   else

-   {

-#ifdef PNG_WRITE_SUPPORTED

-      png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL);

-#endif

-      png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL);

-   }

-

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-   {

-      int i;

-      for (i = 0; i<256; i++)

-         filters_used[i] = 0;

-      png_set_read_user_transform_fn(read_ptr, count_filters);

-   }

-#endif

-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-   zero_samples = 0;

-   png_set_write_user_transform_fn(write_ptr, count_zero_samples);

-#endif

-

-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-#  ifndef PNG_HANDLE_CHUNK_ALWAYS

-#    define PNG_HANDLE_CHUNK_ALWAYS       3

-#  endif

-   png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,

-      png_bytep_NULL, 0);

-#endif

-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-#  ifndef PNG_HANDLE_CHUNK_IF_SAFE

-#    define PNG_HANDLE_CHUNK_IF_SAFE      2

-#  endif

-   png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,

-      png_bytep_NULL, 0);

-#endif

-

-   png_debug(0, "Reading info struct");

-   png_read_info(read_ptr, read_info_ptr);

-

-   png_debug(0, "Transferring info struct");

-   {

-      int interlace_type, compression_type, filter_type;

-

-      if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,

-          &color_type, &interlace_type, &compression_type, &filter_type))

-      {

-         png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-            color_type, interlace_type, compression_type, filter_type);

-#else

-            color_type, PNG_INTERLACE_NONE, compression_type, filter_type);

-#endif

-      }

-   }

-#ifdef PNG_FIXED_POINT_SUPPORTED

-#ifdef PNG_cHRM_SUPPORTED

-   {

-      png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

-         blue_y;

-      if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

-         &red_y, &green_x, &green_y, &blue_x, &blue_y))

-      {

-         png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,

-            red_y, green_x, green_y, blue_x, blue_y);

-      }

-   }

-#endif

-#ifdef PNG_gAMA_SUPPORTED

-   {

-      png_fixed_point gamma;

-

-      if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))

-         png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);

-   }

-#endif

-#else /* Use floating point versions */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-#ifdef PNG_cHRM_SUPPORTED

-   {

-      double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

-         blue_y;

-      if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

-         &red_y, &green_x, &green_y, &blue_x, &blue_y))

-      {

-         png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,

-            red_y, green_x, green_y, blue_x, blue_y);

-      }

-   }

-#endif

-#ifdef PNG_gAMA_SUPPORTED

-   {

-      double gamma;

-

-      if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))

-         png_set_gAMA(write_ptr, write_info_ptr, gamma);

-   }

-#endif

-#endif /* Floating point */

-#endif /* Fixed point */

-#ifdef PNG_iCCP_SUPPORTED

-   {

-      png_charp name;

-      png_charp profile;

-      png_uint_32 proflen;

-      int compression_type;

-

-      if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,

-                      &profile, &proflen))

-      {

-         png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,

-                      profile, proflen);

-      }

-   }

-#endif

-#ifdef PNG_sRGB_SUPPORTED

-   {

-      int intent;

-

-      if (png_get_sRGB(read_ptr, read_info_ptr, &intent))

-         png_set_sRGB(write_ptr, write_info_ptr, intent);

-   }

-#endif

-   {

-      png_colorp palette;

-      int 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);

-   }

-#ifdef PNG_bKGD_SUPPORTED

-   {

-      png_color_16p background;

-

-      if (png_get_bKGD(read_ptr, read_info_ptr, &background))

-      {

-         png_set_bKGD(write_ptr, write_info_ptr, background);

-      }

-   }

-#endif

-#ifdef PNG_hIST_SUPPORTED

-   {

-      png_uint_16p hist;

-

-      if (png_get_hIST(read_ptr, read_info_ptr, &hist))

-         png_set_hIST(write_ptr, write_info_ptr, hist);

-   }

-#endif

-#ifdef PNG_oFFs_SUPPORTED

-   {

-      png_int_32 offset_x, offset_y;

-      int unit_type;

-

-      if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,

-          &unit_type))

-      {

-         png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);

-      }

-   }

-#endif

-#ifdef PNG_pCAL_SUPPORTED

-   {

-      png_charp purpose, units;

-      png_charpp params;

-      png_int_32 X0, X1;

-      int type, nparams;

-

-      if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,

-         &nparams, &units, &params))

-      {

-         png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,

-            nparams, units, params);

-      }

-   }

-#endif

-#ifdef PNG_pHYs_SUPPORTED

-   {

-      png_uint_32 res_x, res_y;

-      int 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);

-   }

-#endif

-#ifdef PNG_sBIT_SUPPORTED

-   {

-      png_color_8p sig_bit;

-

-      if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))

-         png_set_sBIT(write_ptr, write_info_ptr, sig_bit);

-   }

-#endif

-#ifdef PNG_sCAL_SUPPORTED

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-   {

-      int unit;

-      double scal_width, scal_height;

-

-      if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,

-         &scal_height))

-      {

-         png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);

-      }

-   }

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-   {

-      int unit;

-      png_charp scal_width, scal_height;

-

-      if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,

-          &scal_height))

-      {

-         png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, scal_height);

-      }

-   }

-#endif

-#endif

-#endif

-#ifdef PNG_TEXT_SUPPORTED

-   {

-      png_textp text_ptr;

-      int num_text;

-

-      if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)

-      {

-         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);

-         png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);

-      }

-   }

-#endif

-#ifdef PNG_tIME_SUPPORTED

-   {

-      png_timep mod_time;

-

-      if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))

-      {

-         png_set_tIME(write_ptr, write_info_ptr, mod_time);

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-         /* We have to use png_memcpy instead of "=" because the string

-          * pointed to by png_convert_to_rfc1123() gets free'ed before

-          * we use it.

-          */

-         png_memcpy(tIME_string,

-                    png_convert_to_rfc1123(read_ptr, mod_time),

-                    png_sizeof(tIME_string));

-         tIME_string[png_sizeof(tIME_string) - 1] = '\0';

-         tIME_chunk_present++;

-#endif /* PNG_TIME_RFC1123_SUPPORTED */

-      }

-   }

-#endif

-#ifdef PNG_tRNS_SUPPORTED

-   {

-      png_bytep trans;

-      int num_trans;

-      png_color_16p trans_values;

-

-      if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans,

-         &trans_values))

-      {

-         int sample_max = (1 << bit_depth);

-         /* libpng doesn't reject a tRNS chunk with out-of-range samples */

-         if (!((color_type == PNG_COLOR_TYPE_GRAY &&

-             (int)trans_values->gray > sample_max) ||

-             (color_type == PNG_COLOR_TYPE_RGB &&

-             ((int)trans_values->red > sample_max ||

-             (int)trans_values->green > sample_max ||

-             (int)trans_values->blue > sample_max))))

-            png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,

-               trans_values);

-      }

-   }

-#endif

-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   {

-      png_unknown_chunkp unknowns;

-      int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,

-         &unknowns);

-      if (num_unknowns)

-      {

-         png_size_t i;

-         png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,

-           num_unknowns);

-         /* Copy the locations from the read_info_ptr.  The automatically

-          * generated locations in write_info_ptr are wrong because we

-          * haven't written anything yet.

-          */

-         for (i = 0; i < (png_size_t)num_unknowns; i++)

-           png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,

-             unknowns[i].location);

-      }

-   }

-#endif

-

-#ifdef PNG_WRITE_SUPPORTED

-   png_debug(0, "Writing info struct");

-

-/* If we wanted, we could write info in two steps:

- * png_write_info_before_PLTE(write_ptr, write_info_ptr);

- */

-   png_write_info(write_ptr, write_info_ptr);

-

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-   if (user_chunk_data[0] != 0)

-   {

-      png_byte png_sTER[5] = {115,  84,  69,  82, '\0'};

-

-      unsigned char

-        ster_chunk_data[1];

-

-      if (verbose)

-         fprintf(STDERR, "\n stereo mode = %lu\n",

-           (unsigned long)(user_chunk_data[0] - 1));

-      ster_chunk_data[0]=(unsigned char)(user_chunk_data[0] - 1);

-      png_write_chunk(write_ptr, png_sTER, ster_chunk_data, 1);

-   }

-   if (user_chunk_data[1] != 0 || user_chunk_data[2] != 0)

-   {

-      png_byte png_vpAg[5] = {118, 112,  65, 103, '\0'};

-

-      unsigned char

-        vpag_chunk_data[9];

-

-      if (verbose)

-         fprintf(STDERR, " vpAg = %lu x %lu, units = %lu\n",

-           (unsigned long)user_chunk_data[1],

-           (unsigned long)user_chunk_data[2],

-           (unsigned long)user_chunk_data[3]);

-      png_save_uint_32(vpag_chunk_data, user_chunk_data[1]);

-      png_save_uint_32(vpag_chunk_data + 4, user_chunk_data[2]);

-      vpag_chunk_data[8] = (unsigned char)(user_chunk_data[3] & 0xff);

-      png_write_chunk(write_ptr, png_vpAg, vpag_chunk_data, 9);

-   }

-

-#endif

-#endif

-

-#ifdef SINGLE_ROWBUF_ALLOC

-   png_debug(0, "Allocating row buffer...");

-   row_buf = (png_bytep)png_malloc(read_ptr,

-      png_get_rowbytes(read_ptr, read_info_ptr));

-   png_debug1(0, "0x%08lx", (unsigned long)row_buf);

-#endif /* SINGLE_ROWBUF_ALLOC */

-   png_debug(0, "Writing row data");

-

-#if defined(PNG_READ_INTERLACING_SUPPORTED) || \

-  defined(PNG_WRITE_INTERLACING_SUPPORTED)

-   num_pass = png_set_interlace_handling(read_ptr);

-#  ifdef PNG_WRITE_SUPPORTED

-   png_set_interlace_handling(write_ptr);

-#  endif

-#else

-   num_pass = 1;

-#endif

-

-#ifdef PNGTEST_TIMING

-   t_stop = (float)clock();

-   t_misc += (t_stop - t_start);

-   t_start = t_stop;

-#endif

-   for (pass = 0; pass < num_pass; pass++)

-   {

-      png_debug1(0, "Writing row data for pass %d", pass);

-      for (y = 0; y < height; y++)

-      {

-#ifndef SINGLE_ROWBUF_ALLOC

-         png_debug2(0, "Allocating row buffer (pass %d, y = %ld)...", pass, y);

-         row_buf = (png_bytep)png_malloc(read_ptr,

-            png_get_rowbytes(read_ptr, read_info_ptr));

-         png_debug2(0, "0x%08lx (%ld bytes)", (unsigned long)row_buf,

-            png_get_rowbytes(read_ptr, read_info_ptr));

-#endif /* !SINGLE_ROWBUF_ALLOC */

-         png_read_rows(read_ptr, (png_bytepp)&row_buf, png_bytepp_NULL, 1);

-

-#ifdef PNG_WRITE_SUPPORTED

-#ifdef PNGTEST_TIMING

-         t_stop = (float)clock();

-         t_decode += (t_stop - t_start);

-         t_start = t_stop;

-#endif

-         png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);

-#ifdef PNGTEST_TIMING

-         t_stop = (float)clock();

-         t_encode += (t_stop - t_start);

-         t_start = t_stop;

-#endif

-#endif /* PNG_WRITE_SUPPORTED */

-

-#ifndef SINGLE_ROWBUF_ALLOC

-         png_debug2(0, "Freeing row buffer (pass %d, y = %ld)", pass, y);

-         png_free(read_ptr, row_buf);

-         row_buf = NULL;

-#endif /* !SINGLE_ROWBUF_ALLOC */

-      }

-   }

-

-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-   png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);

-#endif

-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);

-#endif

-

-   png_debug(0, "Reading and writing end_info data");

-

-   png_read_end(read_ptr, end_info_ptr);

-#ifdef PNG_TEXT_SUPPORTED

-   {

-      png_textp text_ptr;

-      int num_text;

-

-      if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)

-      {

-         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);

-         png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);

-      }

-   }

-#endif

-#ifdef PNG_tIME_SUPPORTED

-   {

-      png_timep mod_time;

-

-      if (png_get_tIME(read_ptr, end_info_ptr, &mod_time))

-      {

-         png_set_tIME(write_ptr, write_end_info_ptr, mod_time);

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-         /* We have to use png_memcpy instead of "=" because the string

-            pointed to by png_convert_to_rfc1123() gets free'ed before

-            we use it */

-         png_memcpy(tIME_string,

-                    png_convert_to_rfc1123(read_ptr, mod_time),

-                    png_sizeof(tIME_string));

-         tIME_string[png_sizeof(tIME_string) - 1] = '\0';

-         tIME_chunk_present++;

-#endif /* PNG_TIME_RFC1123_SUPPORTED */

-      }

-   }

-#endif

-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   {

-      png_unknown_chunkp unknowns;

-      int num_unknowns;

-      num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr,

-         &unknowns);

-      if (num_unknowns)

-      {

-         png_size_t i;

-         png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,

-           num_unknowns);

-         /* Copy the locations from the read_info_ptr.  The automatically

-          * generated locations in write_end_info_ptr are wrong because we

-          * haven't written the end_info yet.

-          */

-         for (i = 0; i < (png_size_t)num_unknowns; i++)

-           png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,

-             unknowns[i].location);

-      }

-   }

-#endif

-#ifdef PNG_WRITE_SUPPORTED

-   png_write_end(write_ptr, write_end_info_ptr);

-#endif

-

-#ifdef PNG_EASY_ACCESS_SUPPORTED

-   if (verbose)

-   {

-      png_uint_32 iwidth, iheight;

-      iwidth = png_get_image_width(write_ptr, write_info_ptr);

-      iheight = png_get_image_height(write_ptr, write_info_ptr);

-      fprintf(STDERR, "\n Image width = %lu, height = %lu\n",

-         (unsigned long)iwidth, (unsigned long)iheight);

-   }

-#endif

-

-   png_debug(0, "Destroying data structs");

-#ifdef SINGLE_ROWBUF_ALLOC

-   png_debug(1, "destroying row_buf for read_ptr");

-   png_free(read_ptr, row_buf);

-   row_buf = NULL;

-#endif /* SINGLE_ROWBUF_ALLOC */

-   png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr");

-   png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

-#ifdef PNG_WRITE_SUPPORTED

-   png_debug(1, "destroying write_end_info_ptr");

-   png_destroy_info_struct(write_ptr, &write_end_info_ptr);

-   png_debug(1, "destroying write_ptr, write_info_ptr");

-   png_destroy_write_struct(&write_ptr, &write_info_ptr);

-#endif

-   png_debug(0, "Destruction complete.");

-

-   FCLOSE(fpin);

-   FCLOSE(fpout);

-

-   png_debug(0, "Opening files for comparison");

-#ifdef _WIN32_WCE

-   MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);

-   if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)

-#else

-   if ((fpin = fopen(inname, "rb")) == NULL)

-#endif

-   {

-      fprintf(STDERR, "Could not find file %s\n", inname);

-      return (1);

-   }

-

-#ifdef _WIN32_WCE

-   MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);

-   if ((fpout = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)

-#else

-   if ((fpout = fopen(outname, "rb")) == NULL)

-#endif

-   {

-      fprintf(STDERR, "Could not find file %s\n", outname);

-      FCLOSE(fpin);

-      return (1);

-   }

-

-   for (;;)

-   {

-      png_size_t num_in, num_out;

-

-         READFILE(fpin, inbuf, 1, num_in);

-         READFILE(fpout, outbuf, 1, num_out);

-

-      if (num_in != num_out)

-      {

-         fprintf(STDERR, "\nFiles %s and %s are of a different size\n",

-                 inname, outname);

-         if (wrote_question == 0)

-         {

-            fprintf(STDERR,

-         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

-              inname, PNG_ZBUF_SIZE);

-            fprintf(STDERR,

-              "\n   filtering heuristic (libpng default), compression");

-            fprintf(STDERR,

-              " level (zlib default),\n   and zlib version (%s)?\n\n",

-              ZLIB_VERSION);

-            wrote_question = 1;

-         }

-         FCLOSE(fpin);

-         FCLOSE(fpout);

-         return (0);

-      }

-

-      if (!num_in)

-         break;

-

-      if (png_memcmp(inbuf, outbuf, num_in))

-      {

-         fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);

-         if (wrote_question == 0)

-         {

-            fprintf(STDERR,

-         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

-                 inname, PNG_ZBUF_SIZE);

-            fprintf(STDERR,

-              "\n   filtering heuristic (libpng default), compression");

-            fprintf(STDERR,

-              " level (zlib default),\n   and zlib version (%s)?\n\n",

-              ZLIB_VERSION);

-            wrote_question = 1;

-         }

-         FCLOSE(fpin);

-         FCLOSE(fpout);

-         return (0);

-      }

-   }

-

-   FCLOSE(fpin);

-   FCLOSE(fpout);

-

-   return (0);

-}

-

-/* Input and output filenames */

-#ifdef RISCOS

-static PNG_CONST char *inname = "pngtest/png";

-static PNG_CONST char *outname = "pngout/png";

-#else

-static PNG_CONST char *inname = "pngtest.png";

-static PNG_CONST char *outname = "pngout.png";

-#endif

-

-int

-main(int argc, char *argv[])

-{

-   int multiple = 0;

-   int ierror = 0;

-

-   fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);

-   fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);

-   fprintf(STDERR, "%s", png_get_copyright(NULL));

-   /* Show the version of libpng used in building the library */

-   fprintf(STDERR, " library (%lu):%s",

-      (unsigned long)png_access_version_number(),

-      png_get_header_version(NULL));

-   /* Show the version of libpng used in building the application */

-   fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,

-      PNG_HEADER_VERSION_STRING);

-   fprintf(STDERR, " sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n",

-                    (long)png_sizeof(png_struct), (long)png_sizeof(png_info));

-

-   /* 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

-    * tests should be impossible because of the way the macros are set

-    * in pngconf.h

-    */

-#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)

-      fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");

-#endif

-   /* I think the following can happen. */

-#if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)

-      fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");

-#endif

-

-   if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))

-   {

-      fprintf(STDERR,

-         "Warning: versions are different between png.h and png.c\n");

-      fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);

-      fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);

-      ++ierror;

-   }

-

-   if (argc > 1)

-   {

-      if (strcmp(argv[1], "-m") == 0)

-      {

-         multiple = 1;

-         status_dots_requested = 0;

-      }

-      else if (strcmp(argv[1], "-mv") == 0 ||

-               strcmp(argv[1], "-vm") == 0 )

-      {

-         multiple = 1;

-         verbose = 1;

-         status_dots_requested = 1;

-      }

-      else if (strcmp(argv[1], "-v") == 0)

-      {

-         verbose = 1;

-         status_dots_requested = 1;

-         inname = argv[2];

-      }

-      else

-      {

-         inname = argv[1];

-         status_dots_requested = 0;

-      }

-   }

-

-   if (!multiple && argc == 3 + verbose)

-     outname = argv[2 + verbose];

-

-   if ((!multiple && argc > 3 + verbose) || (multiple && argc < 2))

-   {

-     fprintf(STDERR,

-       "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",

-        argv[0], argv[0]);

-     fprintf(STDERR,

-       "  reads/writes one PNG file (without -m) or multiple files (-m)\n");

-     fprintf(STDERR,

-       "  with -m %s is used as a temporary file\n", outname);

-     exit(1);

-   }

-

-   if (multiple)

-   {

-      int i;

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-      int allocation_now = current_allocation;

-#endif

-      for (i=2; i<argc; ++i)

-      {

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-         int k;

-#endif

-         int kerror;

-         fprintf(STDERR, "\n Testing %s:", argv[i]);

-         kerror = test_one_file(argv[i], outname);

-         if (kerror == 0)

-         {

-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-            fprintf(STDERR, "\n PASS (%lu zero samples)\n",

-               (unsigned long)zero_samples);

-#else

-            fprintf(STDERR, " PASS\n");

-#endif

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-            for (k = 0; k<256; k++)

-               if (filters_used[k])

-                  fprintf(STDERR, " Filter %d was used %lu times\n",

-                     k, (unsigned long)filters_used[k]);

-#endif

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-         if (tIME_chunk_present != 0)

-            fprintf(STDERR, " tIME = %s\n", tIME_string);

-         tIME_chunk_present = 0;

-#endif /* PNG_TIME_RFC1123_SUPPORTED */

-         }

-         else

-         {

-            fprintf(STDERR, " FAIL\n");

-            ierror += kerror;

-         }

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         if (allocation_now != current_allocation)

-            fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

-               current_allocation - allocation_now);

-         if (current_allocation != 0)

-         {

-            memory_infop pinfo = pinformation;

-

-            fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

-               current_allocation);

-            while (pinfo != NULL)

-            {

-               fprintf(STDERR, " %lu bytes at %x\n",

-                 (unsigned long)pinfo->size,

-                 (unsigned int) pinfo->pointer);

-               pinfo = pinfo->next;

-            }

-         }

-#endif

-      }

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         fprintf(STDERR, " Current memory allocation: %10d bytes\n",

-            current_allocation);

-         fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

-            maximum_allocation);

-         fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

-            total_allocation);

-         fprintf(STDERR, "     Number of allocations: %10d\n",

-            num_allocations);

-#endif

-   }

-   else

-   {

-      int i;

-      for (i = 0; i<3; ++i)

-      {

-         int kerror;

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         int allocation_now = current_allocation;

-#endif

-         if (i == 1) status_dots_requested = 1;

-         else if (verbose == 0)status_dots_requested = 0;

-         if (i == 0 || verbose == 1 || ierror != 0)

-            fprintf(STDERR, "\n Testing %s:", inname);

-         kerror = test_one_file(inname, outname);

-         if (kerror == 0)

-         {

-            if (verbose == 1 || i == 2)

-            {

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-                int k;

-#endif

-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-                fprintf(STDERR, "\n PASS (%lu zero samples)\n",

-                   (unsigned long)zero_samples);

-#else

-                fprintf(STDERR, " PASS\n");

-#endif

-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-                for (k = 0; k<256; k++)

-                   if (filters_used[k])

-                      fprintf(STDERR, " Filter %d was used %lu times\n",

-                         k,

-                         (unsigned long)filters_used[k]);

-#endif

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-             if (tIME_chunk_present != 0)

-                fprintf(STDERR, " tIME = %s\n", tIME_string);

-#endif /* PNG_TIME_RFC1123_SUPPORTED */

-            }

-         }

-         else

-         {

-            if (verbose == 0 && i != 2)

-               fprintf(STDERR, "\n Testing %s:", inname);

-            fprintf(STDERR, " FAIL\n");

-            ierror += kerror;

-         }

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         if (allocation_now != current_allocation)

-             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

-               current_allocation - allocation_now);

-         if (current_allocation != 0)

-         {

-             memory_infop pinfo = pinformation;

-

-             fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

-                current_allocation);

-             while (pinfo != NULL)

-             {

-                fprintf(STDERR, " %lu bytes at %x\n",

-                   (unsigned long)pinfo->size, (unsigned int)pinfo->pointer);

-                pinfo = pinfo->next;

-             }

-          }

-#endif

-       }

-#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-       fprintf(STDERR, " Current memory allocation: %10d bytes\n",

-          current_allocation);

-       fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

-          maximum_allocation);

-       fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

-          total_allocation);

-       fprintf(STDERR, "     Number of allocations: %10d\n",

-            num_allocations);

-#endif

-   }

-

-#ifdef PNGTEST_TIMING

-   t_stop = (float)clock();

-   t_misc += (t_stop - t_start);

-   t_start = t_stop;

-   fprintf(STDERR, " CPU time used = %.3f seconds",

-      (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);

-   fprintf(STDERR, " (decoding %.3f,\n",

-      t_decode/(float)CLOCKS_PER_SEC);

-   fprintf(STDERR, "        encoding %.3f ,",

-      t_encode/(float)CLOCKS_PER_SEC);

-   fprintf(STDERR, " other %.3f seconds)\n\n",

-      t_misc/(float)CLOCKS_PER_SEC);

-#endif

-

-   if (ierror == 0)

-      fprintf(STDERR, " libpng passes test\n");

-   else

-      fprintf(STDERR, " libpng FAILS test\n");

-   return (int)(ierror != 0);

-}

-

-/* Generate a compiler error if there is an old png.h in the search path. */

-typedef version_1_2_41 your_png_h_is_not_version_1_2_41;

+
+/* pngtest.c - a simple test program to test libpng
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This program reads in a PNG image, writes it out again, and then
+ * compares the two files.  If the files are identical, this shows that
+ * the basic chunk handling, filtering, and (de)compression code is working
+ * properly.  It does not currently test all of the transforms, although
+ * it probably should.
+ *
+ * The program will report "FAIL" in certain legitimate cases:
+ * 1) when the compression level or filter selection method is changed.
+ * 2) when the maximum IDAT size (PNG_ZBUF_SIZE in pngconf.h) is not 8192.
+ * 3) unknown unsafe-to-copy ancillary chunks or unknown critical chunks
+ *    exist in the input file.
+ * 4) others not listed here...
+ * In these cases, it is best to check with another tool such as "pngcheck"
+ * to see what the differences between the two files are.
+ *
+ * If a filename is given on the command-line, then this file is used
+ * for the input, rather than the default "pngtest.png".  This allows
+ * testing a wide variety of files easily.  You can also test a number
+ * of files at once by typing "pngtest -m file1.png file2.png ..."
+ */
+
+#include "png.h"
+#include "pngpriv.h"
+
+#  include <stdio.h>
+#  include <stdlib.h>
+#  define FCLOSE(file) fclose(file)
+
+#ifndef PNG_STDIO_SUPPORTED
+     typedef FILE                * png_FILE_p;
+#endif
+
+/* Makes pngtest verbose so we can find problems (needs to be before png.h) */
+#ifndef PNG_DEBUG
+#  define PNG_DEBUG 0
+#endif
+
+#if !PNG_DEBUG
+#  define SINGLE_ROWBUF_ALLOC  /* Makes buffer overruns easier to nail */
+#endif
+
+/* Turn on CPU timing
+#define PNGTEST_TIMING
+*/
+
+#ifndef PNG_FLOATING_POINT_SUPPORTED
+#undef PNGTEST_TIMING
+#endif
+
+#ifdef PNGTEST_TIMING
+static float t_start, t_stop, t_decode, t_encode, t_misc;
+#include <time.h>
+#endif
+
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+#define PNG_tIME_STRING_LENGTH 29
+static int tIME_chunk_present = 0;
+static char tIME_string[PNG_tIME_STRING_LENGTH] = "tIME chunk is not present";
+#endif
+
+static int verbose = 0;
+
+int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
+
+#ifdef __TURBOC__
+#include <mem.h>
+#endif
+
+/* Defined so I can write to a file on gui/windowing platforms */
+/*  #define STDERR stderr  */
+#define STDERR stdout   /* For DOS */
+
+/* In case a system header (e.g., on AIX) defined jmpbuf */
+#ifdef jmpbuf
+#  undef jmpbuf
+#endif
+
+/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
+#ifndef png_jmpbuf
+#  define png_jmpbuf(png_ptr) png_ptr->jmpbuf
+#endif
+
+/* Example of using row callbacks to make a simple progress meter */
+static int status_pass = 1;
+static int status_dots_requested = 0;
+static int status_dots = 1;
+
+void
+read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
+void
+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 (status_pass != pass)
+   {
+      fprintf(stdout, "\n Pass %d: ", pass);
+      status_pass = pass;
+      status_dots = 31;
+   }
+   status_dots--;
+   if (status_dots == 0)
+   {
+      fprintf(stdout, "\n         ");
+      status_dots=30;
+   }
+   fprintf(stdout, "r");
+}
+
+void
+write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
+void
+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;
+   fprintf(stdout, "w");
+}
+
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+/* Example of using user transform callback (we don't transform anything,
+ * but merely examine the row filters.  We set this to 256 rather than
+ * 5 in case illegal filter values are present.)
+ */
+static png_uint_32 filters_used[256];
+void
+count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data);
+void
+count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
+{
+   if (png_ptr != NULL && row_info != NULL)
+      ++filters_used[*(data - 1)];
+}
+#endif
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+/* Example of using user transform callback (we don't transform anything,
+ * but merely count the zero samples)
+ */
+
+static png_uint_32 zero_samples;
+
+void
+count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data);
+void
+count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
+{
+   png_bytep dp = data;
+   if (png_ptr == NULL)return;
+
+   /* Contents of row_info:
+    *  png_uint_32 width      width of row
+    *  png_uint_32 rowbytes   number of bytes in row
+    *  png_byte color_type    color type of pixels
+    *  png_byte bit_depth     bit depth of samples
+    *  png_byte channels      number of channels (1-4)
+    *  png_byte pixel_depth   bits per pixel (depth*channels)
+    */
+
+    /* 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)
+    {
+       int pos = 0;
+       png_uint_32 n, nstop;
+       for (n = 0, nstop=row_info->width; n<nstop; n++)
+       {
+          if (row_info->bit_depth == 1)
+          {
+             if (((*dp << pos++ ) & 0x80) == 0)
+                zero_samples++;
+             if (pos == 8)
+             {
+                pos = 0;
+                dp++;
+             }
+          }
+          if (row_info->bit_depth == 2)
+          {
+             if (((*dp << (pos+=2)) & 0xc0) == 0)
+                zero_samples++;
+             if (pos == 8)
+             {
+                pos = 0;
+                dp++;
+             }
+          }
+          if (row_info->bit_depth == 4)
+          {
+             if (((*dp << (pos+=4)) & 0xf0) == 0)
+                zero_samples++;
+             if (pos == 8)
+             {
+                pos = 0;
+                dp++;
+             }
+          }
+          if (row_info->bit_depth == 8)
+             if (*dp++ == 0)
+                zero_samples++;
+          if (row_info->bit_depth == 16)
+          {
+             if ((*dp | *(dp+1)) == 0)
+                zero_samples++;
+             dp+=2;
+          }
+       }
+    }
+    else /* Other color types */
+    {
+       png_uint_32 n, nstop;
+       int channel;
+       int color_channels = row_info->channels;
+       if (row_info->color_type > 3)color_channels--;
+
+       for (n = 0, nstop=row_info->width; n<nstop; n++)
+       {
+          for (channel = 0; channel < color_channels; channel++)
+          {
+             if (row_info->bit_depth == 8)
+                if (*dp++ == 0)
+                   zero_samples++;
+             if (row_info->bit_depth == 16)
+             {
+                if ((*dp | *(dp+1)) == 0)
+                   zero_samples++;
+                dp+=2;
+             }
+          }
+          if (row_info->color_type > 3)
+          {
+             dp++;
+             if (row_info->bit_depth == 16)
+                dp++;
+          }
+       }
+    }
+}
+#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */
+
+static int wrote_question = 0;
+
+#ifndef PNG_STDIO_SUPPORTED
+/* START of code to validate stdio-free compilation */
+/* 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.
+ * 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
+ * read_data function and use it at run time with png_set_read_fn(), rather
+ * than changing the library.
+ */
+
+#ifndef USE_FAR_KEYWORD
+static void
+pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check = 0;
+   png_voidp io_ptr;
+
+   /* 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.
+    */
+   io_ptr = png_get_io_ptr(png_ptr);
+   if (io_ptr != NULL)
+   {
+      check = fread(data, 1, length, (png_FILE_p)io_ptr);
+   }
+
+   if (check != length)
+   {
+      png_error(png_ptr, "Read Error!");
+   }
+}
+#else
+/* This is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+static void
+pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+   png_byte *n_data;
+   png_FILE_p io_ptr;
+
+   /* Check if data really is near. If so, use usual code. */
+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)n_data == data)
+   {
+      check = fread(n_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t read, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         read = MIN(NEAR_BUF_SIZE, remaining);
+         err = fread(buf, 1, 1, io_ptr);
+         png_memcpy(data, buf, read); /* Copy far buffer to near buffer */
+         if (err != read)
+            break;
+         else
+            check += err;
+         data += read;
+         remaining -= read;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+      png_error(png_ptr, "read Error");
+}
+#endif /* USE_FAR_KEYWORD */
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+static void
+pngtest_flush(png_structp png_ptr)
+{
+   /* Do nothing; fflush() is said to be just a waste of energy. */
+   png_ptr = png_ptr;  /* Stifle compiler warning */
+}
+#endif
+
+/* 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
+ * write_data function and use it at run time with png_set_write_fn(), rather
+ * than changing the library.
+ */
+#ifndef USE_FAR_KEYWORD
+static void
+pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+
+   check = fwrite(data, 1, length, (png_FILE_p)png_ptr->io_ptr);
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+#else
+/* This is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+static void
+pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */
+   png_FILE_p io_ptr;
+
+   /* Check if data really is near. If so, use usual code. */
+   near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)near_data == data)
+   {
+      check = fwrite(near_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t written, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         written = MIN(NEAR_BUF_SIZE, remaining);
+         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
+         err = fwrite(buf, 1, written, io_ptr);
+         if (err != written)
+            break;
+         else
+            check += err;
+         data += written;
+         remaining -= written;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+#endif /* USE_FAR_KEYWORD */
+
+/* This function is called when there is a warning, but the library thinks
+ * it can continue anyway.  Replacement functions don't have to do anything
+ * here if you don't want to.  In the default configuration, png_ptr is
+ * not used, but it is passed in case it may be useful.
+ */
+static void
+pngtest_warning(png_structp png_ptr, png_const_charp message)
+{
+   PNG_CONST char *name = "UNKNOWN (ERROR!)";
+   char *test;
+   test = png_get_error_ptr(png_ptr);
+   if (test == NULL)
+     fprintf(STDERR, "%s: libpng warning: %s\n", name, message);
+   else
+     fprintf(STDERR, "%s: libpng warning: %s\n", test, message);
+}
+
+/* This is the default error handling function.  Note that replacements for
+ * this function MUST NOT RETURN, or the program will likely crash.  This
+ * function is used by default, or if the program supplies NULL for the
+ * error function pointer in png_set_error_fn().
+ */
+static void
+pngtest_error(png_structp png_ptr, png_const_charp message)
+{
+   pngtest_warning(png_ptr, message);
+   /* We can return because png_error calls the default handler, which is
+    * actually OK in this case.
+    */
+}
+#endif /* !PNG_STDIO_SUPPORTED */
+/* END of code to validate stdio-free compilation */
+
+/* START of code to validate memory allocation and deallocation */
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+
+/* Allocate memory.  For reasonable files, size should never exceed
+ * 64K.  However, zlib may allocate more then 64K if you don't tell
+ * it not to.  See zconf.h and png.h for more information.  zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ *
+ * 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.
+ */
+typedef struct memory_information
+{
+   png_alloc_size_t          size;
+   png_voidp                 pointer;
+   struct memory_information FAR *next;
+} memory_information;
+typedef memory_information FAR *memory_infop;
+
+static memory_infop pinformation = NULL;
+static int current_allocation = 0;
+static int maximum_allocation = 0;
+static int total_allocation = 0;
+static int num_allocations = 0;
+
+png_voidp png_debug_malloc
+   PNGARG((png_structp png_ptr, png_alloc_size_t size));
+void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr));
+
+png_voidp
+png_debug_malloc(png_structp png_ptr, png_alloc_size_t size)
+{
+
+   /* png_malloc has already tested for NULL; png_create_struct calls
+    * png_debug_malloc directly, with png_ptr == NULL which is OK
+    */
+
+   if (size == 0)
+      return (NULL);
+
+   /* This calls the library allocator twice, once to get the requested
+      buffer and once to get a new free list entry. */
+   {
+      /* Disable malloc_fn and free_fn */
+      memory_infop pinfo;
+      png_set_mem_fn(png_ptr, NULL, NULL, NULL);
+      pinfo = (memory_infop)png_malloc(png_ptr,
+         png_sizeof(*pinfo));
+      pinfo->size = size;
+      current_allocation += size;
+      total_allocation += size;
+      num_allocations ++;
+      if (current_allocation > maximum_allocation)
+         maximum_allocation = current_allocation;
+      pinfo->pointer = png_malloc(png_ptr, size);
+      /* Restore malloc_fn and free_fn */
+      png_set_mem_fn(png_ptr,
+          NULL, png_debug_malloc, png_debug_free);
+      if (size != 0 && pinfo->pointer == NULL)
+      {
+         current_allocation -= size;
+         total_allocation -= size;
+         png_error(png_ptr,
+           "out of memory in pngtest->png_debug_malloc");
+      }
+      pinfo->next = pinformation;
+      pinformation = pinfo;
+      /* Make sure the caller isn't assuming zeroed memory. */
+      png_memset(pinfo->pointer, 0xdd, pinfo->size);
+      if (verbose)
+         printf("png_malloc %lu bytes at %x\n", (unsigned long)size,
+            pinfo->pointer);
+      return (png_voidp)(pinfo->pointer);
+   }
+}
+
+/* Free a pointer.  It is removed from the list at the same time. */
+void
+png_debug_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL)
+      fprintf(STDERR, "NULL pointer to png_debug_free.\n");
+   if (ptr == 0)
+   {
+#if 0 /* This happens all the time. */
+      fprintf(STDERR, "WARNING: freeing NULL pointer\n");
+#endif
+      return;
+   }
+
+   /* Unlink the element from the list. */
+   {
+      memory_infop FAR *ppinfo = &pinformation;
+      for (;;)
+      {
+         memory_infop pinfo = *ppinfo;
+         if (pinfo->pointer == ptr)
+         {
+            *ppinfo = pinfo->next;
+            current_allocation -= pinfo->size;
+            if (current_allocation < 0)
+               fprintf(STDERR, "Duplicate free of memory\n");
+            /* We must free the list element too, but first kill
+               the memory that is to be freed. */
+            png_memset(ptr, 0x55, pinfo->size);
+            png_free_default(png_ptr, pinfo);
+            pinfo = NULL;
+            break;
+         }
+         if (pinfo->next == NULL)
+         {
+            fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);
+            break;
+         }
+         ppinfo = &pinfo->next;
+      }
+   }
+
+   /* Finally free the data. */
+   if (verbose)
+      printf("Freeing %x\n", ptr);
+   png_free_default(png_ptr, ptr);
+   ptr = NULL;
+}
+#endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */
+/* END of code to test memory allocation/deallocation */
+
+
+/* Demonstration of user chunk support of the sTER and vpAg chunks */
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+
+/* (sTER is a public chunk not yet known by libpng.  vpAg is a private
+chunk used in ImageMagick to store "virtual page" size).  */
+
+static png_uint_32 user_chunk_data[4];
+
+    /* 0: sTER mode + 1
+     * 1: vpAg width
+     * 2: vpAg height
+     * 3: vpAg units
+     */
+
+static int read_user_chunk_callback(png_struct *png_ptr,
+   png_unknown_chunkp chunk)
+{
+   png_uint_32
+     *my_user_chunk_data;
+
+   /* Return one of the following:
+    *    return (-n);  chunk had an error
+    *    return (0);  did not recognize
+    *    return (n);  success
+    *
+    * The unknown chunk structure contains the chunk data:
+    * png_byte name[5];
+    * png_byte *data;
+    * png_size_t size;
+    *
+    * Note that libpng has already taken care of the CRC handling.
+    */
+
+   if (chunk->name[0] == 115 && chunk->name[1] ==  84 &&     /* s  T */
+       chunk->name[2] ==  69 && chunk->name[3] ==  82)       /* E  R */
+      {
+         /* Found sTER chunk */
+         if (chunk->size != 1)
+            return (-1); /* Error return */
+         if (chunk->data[0] != 0 && chunk->data[0] != 1)
+            return (-1);  /* Invalid mode */
+         my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
+         my_user_chunk_data[0]=chunk->data[0]+1;
+         return (1);
+      }
+
+   if (chunk->name[0] != 118 || chunk->name[1] != 112 ||    /* v  p */
+       chunk->name[2] !=  65 || chunk->name[3] != 103)      /* A  g */
+      return (0); /* Did not recognize */
+
+   /* Found ImageMagick vpAg chunk */
+
+   if (chunk->size != 9)
+      return (-1); /* Error return */
+
+   my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
+
+   my_user_chunk_data[1]=png_get_uint_31(png_ptr, chunk->data);
+   my_user_chunk_data[2]=png_get_uint_31(png_ptr, chunk->data + 4);
+   my_user_chunk_data[3]=(png_uint_32)chunk->data[8];
+
+   return (1);
+
+}
+#endif
+/* END of code to demonstrate user chunk support */
+
+/* Test one file */
+int
+test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
+{
+   static png_FILE_p fpin;
+   static png_FILE_p fpout;  /* "static" prevents setjmp corruption */
+   png_structp read_ptr;
+   png_infop read_info_ptr, end_info_ptr;
+#ifdef PNG_WRITE_SUPPORTED
+   png_structp write_ptr;
+   png_infop write_info_ptr;
+   png_infop write_end_info_ptr;
+#else
+   png_structp write_ptr = NULL;
+   png_infop write_info_ptr = NULL;
+   png_infop write_end_info_ptr = NULL;
+#endif
+   png_bytep row_buf;
+   png_uint_32 y;
+   png_uint_32 width, height;
+   int num_pass, pass;
+   int bit_depth, color_type;
+#ifdef PNG_SETJMP_SUPPORTED
+#ifdef USE_FAR_KEYWORD
+   jmp_buf jmpbuf;
+#endif
+#endif
+
+   char inbuf[256], outbuf[256];
+
+   row_buf = NULL;
+
+   if ((fpin = fopen(inname, "rb")) == NULL)
+   {
+      fprintf(STDERR, "Could not find input file %s\n", inname);
+      return (1);
+   }
+
+   if ((fpout = fopen(outname, "wb")) == NULL)
+   {
+      fprintf(STDERR, "Could not open output file %s\n", outname);
+      FCLOSE(fpin);
+      return (1);
+   }
+
+   png_debug(0, "Allocating read and write structures");
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+   read_ptr =
+      png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL,
+      NULL, NULL, NULL,
+      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);
+#else
+   read_ptr =
+      png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+#endif
+#ifndef PNG_STDIO_SUPPORTED
+   png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,
+       pngtest_warning);
+#endif
+
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+   user_chunk_data[0] = 0;
+   user_chunk_data[1] = 0;
+   user_chunk_data[2] = 0;
+   user_chunk_data[3] = 0;
+   png_set_read_user_chunk_fn(read_ptr, user_chunk_data,
+     read_user_chunk_callback);
+
+#endif
+#ifdef PNG_WRITE_SUPPORTED
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+   write_ptr =
+      png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL,
+      NULL, NULL, NULL, png_debug_malloc, png_debug_free);
+#else
+   write_ptr =
+      png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+#endif
+#ifndef PNG_STDIO_SUPPORTED
+   png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,
+       pngtest_warning);
+#endif
+#endif
+   png_debug(0, "Allocating read_info, write_info and end_info structures");
+   read_info_ptr = png_create_info_struct(read_ptr);
+   end_info_ptr = png_create_info_struct(read_ptr);
+#ifdef PNG_WRITE_SUPPORTED
+   write_info_ptr = png_create_info_struct(write_ptr);
+   write_end_info_ptr = png_create_info_struct(write_ptr);
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+   png_debug(0, "Setting jmpbuf for read struct");
+#ifdef USE_FAR_KEYWORD
+   if (setjmp(jmpbuf))
+#else
+   if (setjmp(png_jmpbuf(read_ptr)))
+#endif
+   {
+      fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);
+      png_free(read_ptr, row_buf);
+      row_buf = NULL;
+      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
+#ifdef PNG_WRITE_SUPPORTED
+      png_destroy_info_struct(write_ptr, &write_end_info_ptr);
+      png_destroy_write_struct(&write_ptr, &write_info_ptr);
+#endif
+      FCLOSE(fpin);
+      FCLOSE(fpout);
+      return (1);
+   }
+#ifdef USE_FAR_KEYWORD
+   png_memcpy(png_jmpbuf(read_ptr), jmpbuf, png_sizeof(jmp_buf));
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+   png_debug(0, "Setting jmpbuf for write struct");
+#ifdef USE_FAR_KEYWORD
+   if (setjmp(jmpbuf))
+#else
+   if (setjmp(png_jmpbuf(write_ptr)))
+#endif
+   {
+      fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);
+      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
+      png_destroy_info_struct(write_ptr, &write_end_info_ptr);
+#ifdef PNG_WRITE_SUPPORTED
+      png_destroy_write_struct(&write_ptr, &write_info_ptr);
+#endif
+      FCLOSE(fpin);
+      FCLOSE(fpout);
+      return (1);
+   }
+#ifdef USE_FAR_KEYWORD
+   png_memcpy(png_jmpbuf(write_ptr), jmpbuf, png_sizeof(jmp_buf));
+#endif
+#endif
+#endif
+
+   png_debug(0, "Initializing input and output streams");
+#ifdef PNG_STDIO_SUPPORTED
+   png_init_io(read_ptr, fpin);
+#  ifdef PNG_WRITE_SUPPORTED
+   png_init_io(write_ptr, fpout);
+#  endif
+#else
+   png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);
+#  ifdef PNG_WRITE_SUPPORTED
+   png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,
+#    ifdef PNG_WRITE_FLUSH_SUPPORTED
+      pngtest_flush);
+#    else
+      NULL);
+#    endif
+#  endif
+#endif
+   if (status_dots_requested == 1)
+   {
+#ifdef PNG_WRITE_SUPPORTED
+      png_set_write_status_fn(write_ptr, write_row_callback);
+#endif
+      png_set_read_status_fn(read_ptr, read_row_callback);
+   }
+   else
+   {
+#ifdef PNG_WRITE_SUPPORTED
+      png_set_write_status_fn(write_ptr, NULL);
+#endif
+      png_set_read_status_fn(read_ptr, NULL);
+   }
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+   {
+      int i;
+      for (i = 0; i<256; i++)
+         filters_used[i] = 0;
+      png_set_read_user_transform_fn(read_ptr, count_filters);
+   }
+#endif
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+   zero_samples = 0;
+   png_set_write_user_transform_fn(write_ptr, count_zero_samples);
+#endif
+
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+#  ifndef PNG_HANDLE_CHUNK_ALWAYS
+#    define PNG_HANDLE_CHUNK_ALWAYS       3
+#  endif
+   png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,
+      NULL, 0);
+#endif
+#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+#  ifndef PNG_HANDLE_CHUNK_IF_SAFE
+#    define PNG_HANDLE_CHUNK_IF_SAFE      2
+#  endif
+   png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,
+      NULL, 0);
+#endif
+
+   png_debug(0, "Reading info struct");
+   png_read_info(read_ptr, read_info_ptr);
+
+   png_debug(0, "Transferring info struct");
+   {
+      int interlace_type, compression_type, filter_type;
+
+      if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
+          &color_type, &interlace_type, &compression_type, &filter_type))
+      {
+         png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+            color_type, interlace_type, compression_type, filter_type);
+#else
+            color_type, PNG_INTERLACE_NONE, compression_type, filter_type);
+#endif
+      }
+   }
+#ifdef PNG_FIXED_POINT_SUPPORTED
+#ifdef PNG_cHRM_SUPPORTED
+   {
+      png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
+         blue_y;
+      if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
+         &red_y, &green_x, &green_y, &blue_x, &blue_y))
+      {
+         png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,
+            red_y, green_x, green_y, blue_x, blue_y);
+      }
+   }
+#endif
+#ifdef PNG_gAMA_SUPPORTED
+   {
+      png_fixed_point gamma;
+
+      if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))
+         png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
+   }
+#endif
+#else /* Use floating point versions */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+#ifdef PNG_cHRM_SUPPORTED
+   {
+      double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
+         blue_y;
+      if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
+         &red_y, &green_x, &green_y, &blue_x, &blue_y))
+      {
+         png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
+            red_y, green_x, green_y, blue_x, blue_y);
+      }
+   }
+#endif
+#ifdef PNG_gAMA_SUPPORTED
+   {
+      double gamma;
+
+      if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
+         png_set_gAMA(write_ptr, write_info_ptr, gamma);
+   }
+#endif
+#endif /* Floating point */
+#endif /* Fixed point */
+#ifdef PNG_iCCP_SUPPORTED
+   {
+      png_charp name;
+      png_charp profile;
+      png_uint_32 proflen;
+      int compression_type;
+
+      if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,
+                      &profile, &proflen))
+      {
+         png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,
+                      profile, proflen);
+      }
+   }
+#endif
+#ifdef PNG_sRGB_SUPPORTED
+   {
+      int intent;
+
+      if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
+         png_set_sRGB(write_ptr, write_info_ptr, intent);
+   }
+#endif
+   {
+      png_colorp palette;
+      int 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);
+   }
+#ifdef PNG_bKGD_SUPPORTED
+   {
+      png_color_16p background;
+
+      if (png_get_bKGD(read_ptr, read_info_ptr, &background))
+      {
+         png_set_bKGD(write_ptr, write_info_ptr, background);
+      }
+   }
+#endif
+#ifdef PNG_hIST_SUPPORTED
+   {
+      png_uint_16p hist;
+
+      if (png_get_hIST(read_ptr, read_info_ptr, &hist))
+         png_set_hIST(write_ptr, write_info_ptr, hist);
+   }
+#endif
+#ifdef PNG_oFFs_SUPPORTED
+   {
+      png_int_32 offset_x, offset_y;
+      int unit_type;
+
+      if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,
+          &unit_type))
+      {
+         png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
+      }
+   }
+#endif
+#ifdef PNG_pCAL_SUPPORTED
+   {
+      png_charp purpose, units;
+      png_charpp params;
+      png_int_32 X0, X1;
+      int type, nparams;
+
+      if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
+         &nparams, &units, &params))
+      {
+         png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
+            nparams, units, params);
+      }
+   }
+#endif
+#ifdef PNG_pHYs_SUPPORTED
+   {
+      png_uint_32 res_x, res_y;
+      int 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);
+   }
+#endif
+#ifdef PNG_sBIT_SUPPORTED
+   {
+      png_color_8p sig_bit;
+
+      if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
+         png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
+   }
+#endif
+#ifdef PNG_sCAL_SUPPORTED
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   {
+      int unit;
+      double scal_width, scal_height;
+
+      if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,
+         &scal_height))
+      {
+         png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);
+      }
+   }
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+   {
+      int unit;
+      png_charp scal_width, scal_height;
+
+      if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,
+          &scal_height))
+      {
+         png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, scal_height);
+      }
+   }
+#endif
+#endif
+#endif
+#ifdef PNG_TEXT_SUPPORTED
+   {
+      png_textp text_ptr;
+      int num_text;
+
+      if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
+      {
+         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);
+         png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
+      }
+   }
+#endif
+#ifdef PNG_tIME_SUPPORTED
+   {
+      png_timep mod_time;
+
+      if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))
+      {
+         png_set_tIME(write_ptr, write_info_ptr, mod_time);
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+         /* We have to use png_memcpy instead of "=" because the string
+          * pointed to by png_convert_to_rfc1123() gets free'ed before
+          * we use it.
+          */
+         png_memcpy(tIME_string,
+                    png_convert_to_rfc1123(read_ptr, mod_time),
+                    png_sizeof(tIME_string));
+         tIME_string[png_sizeof(tIME_string) - 1] = '\0';
+         tIME_chunk_present++;
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+      }
+   }
+#endif
+#ifdef PNG_tRNS_SUPPORTED
+   {
+      png_bytep trans_alpha;
+      int num_trans;
+      png_color_16p trans_color;
+
+      if (png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans,
+         &trans_color))
+      {
+         int sample_max = (1 << bit_depth);
+         /* libpng doesn't reject a tRNS chunk with out-of-range samples */
+         if (!((color_type == PNG_COLOR_TYPE_GRAY &&
+             (int)trans_color->gray > sample_max) ||
+             (color_type == PNG_COLOR_TYPE_RGB &&
+             ((int)trans_color->red > sample_max ||
+             (int)trans_color->green > sample_max ||
+             (int)trans_color->blue > sample_max))))
+            png_set_tRNS(write_ptr, write_info_ptr, trans_alpha, num_trans,
+               trans_color);
+      }
+   }
+#endif
+#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+   {
+      png_unknown_chunkp unknowns;
+      int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,
+         &unknowns);
+      if (num_unknowns)
+      {
+         png_size_t i;
+         png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
+           num_unknowns);
+         /* Copy the locations from the read_info_ptr.  The automatically
+          * generated locations in write_info_ptr are wrong because we
+          * haven't written anything yet.
+          */
+         for (i = 0; i < (png_size_t)num_unknowns; i++)
+           png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
+             unknowns[i].location);
+      }
+   }
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+   png_debug(0, "Writing info struct");
+
+/* If we wanted, we could write info in two steps:
+ * png_write_info_before_PLTE(write_ptr, write_info_ptr);
+ */
+   png_write_info(write_ptr, write_info_ptr);
+
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+   if (user_chunk_data[0] != 0)
+   {
+      png_byte png_sTER[5] = {115,  84,  69,  82, '\0'};
+
+      unsigned char
+        ster_chunk_data[1];
+
+      if (verbose)
+         fprintf(STDERR, "\n stereo mode = %lu\n",
+           (unsigned long)(user_chunk_data[0] - 1));
+      ster_chunk_data[0]=(unsigned char)(user_chunk_data[0] - 1);
+      png_write_chunk(write_ptr, png_sTER, ster_chunk_data, 1);
+   }
+   if (user_chunk_data[1] != 0 || user_chunk_data[2] != 0)
+   {
+      png_byte png_vpAg[5] = {118, 112,  65, 103, '\0'};
+
+      unsigned char
+        vpag_chunk_data[9];
+
+      if (verbose)
+         fprintf(STDERR, " vpAg = %lu x %lu, units = %lu\n",
+           (unsigned long)user_chunk_data[1],
+           (unsigned long)user_chunk_data[2],
+           (unsigned long)user_chunk_data[3]);
+      png_save_uint_32(vpag_chunk_data, user_chunk_data[1]);
+      png_save_uint_32(vpag_chunk_data + 4, user_chunk_data[2]);
+      vpag_chunk_data[8] = (unsigned char)(user_chunk_data[3] & 0xff);
+      png_write_chunk(write_ptr, png_vpAg, vpag_chunk_data, 9);
+   }
+
+#endif
+#endif
+
+#ifdef SINGLE_ROWBUF_ALLOC
+   png_debug(0, "Allocating row buffer...");
+   row_buf = (png_bytep)png_malloc(read_ptr,
+      png_get_rowbytes(read_ptr, read_info_ptr));
+   png_debug1(0, "0x%08lx", (unsigned long)row_buf);
+#endif /* SINGLE_ROWBUF_ALLOC */
+   png_debug(0, "Writing row data");
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+  defined(PNG_WRITE_INTERLACING_SUPPORTED)
+   num_pass = png_set_interlace_handling(read_ptr);
+#  ifdef PNG_WRITE_SUPPORTED
+   png_set_interlace_handling(write_ptr);
+#  endif
+#else
+   num_pass = 1;
+#endif
+
+#ifdef PNGTEST_TIMING
+   t_stop = (float)clock();
+   t_misc += (t_stop - t_start);
+   t_start = t_stop;
+#endif
+   for (pass = 0; pass < num_pass; pass++)
+   {
+      png_debug1(0, "Writing row data for pass %d", pass);
+      for (y = 0; y < height; y++)
+      {
+#ifndef SINGLE_ROWBUF_ALLOC
+         png_debug2(0, "Allocating row buffer (pass %d, y = %ld)...", pass, y);
+         row_buf = (png_bytep)png_malloc(read_ptr,
+            png_get_rowbytes(read_ptr, read_info_ptr));
+         png_debug2(0, "0x%08lx (%ld bytes)", (unsigned long)row_buf,
+            png_get_rowbytes(read_ptr, read_info_ptr));
+#endif /* !SINGLE_ROWBUF_ALLOC */
+         png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1);
+
+#ifdef PNG_WRITE_SUPPORTED
+#ifdef PNGTEST_TIMING
+         t_stop = (float)clock();
+         t_decode += (t_stop - t_start);
+         t_start = t_stop;
+#endif
+         png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
+#ifdef PNGTEST_TIMING
+         t_stop = (float)clock();
+         t_encode += (t_stop - t_start);
+         t_start = t_stop;
+#endif
+#endif /* PNG_WRITE_SUPPORTED */
+
+#ifndef SINGLE_ROWBUF_ALLOC
+         png_debug2(0, "Freeing row buffer (pass %d, y = %ld)", pass, y);
+         png_free(read_ptr, row_buf);
+         row_buf = NULL;
+#endif /* !SINGLE_ROWBUF_ALLOC */
+      }
+   }
+
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+   png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);
+#endif
+#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+   png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);
+#endif
+
+   png_debug(0, "Reading and writing end_info data");
+
+   png_read_end(read_ptr, end_info_ptr);
+#ifdef PNG_TEXT_SUPPORTED
+   {
+      png_textp text_ptr;
+      int num_text;
+
+      if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)
+      {
+         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);
+         png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);
+      }
+   }
+#endif
+#ifdef PNG_tIME_SUPPORTED
+   {
+      png_timep mod_time;
+
+      if (png_get_tIME(read_ptr, end_info_ptr, &mod_time))
+      {
+         png_set_tIME(write_ptr, write_end_info_ptr, mod_time);
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+         /* We have to use png_memcpy instead of "=" because the string
+            pointed to by png_convert_to_rfc1123() gets free'ed before
+            we use it */
+         png_memcpy(tIME_string,
+                    png_convert_to_rfc1123(read_ptr, mod_time),
+                    png_sizeof(tIME_string));
+         tIME_string[png_sizeof(tIME_string) - 1] = '\0';
+         tIME_chunk_present++;
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+      }
+   }
+#endif
+#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+   {
+      png_unknown_chunkp unknowns;
+      int num_unknowns;
+      num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr,
+         &unknowns);
+      if (num_unknowns)
+      {
+         png_size_t i;
+         png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
+           num_unknowns);
+         /* Copy the locations from the read_info_ptr.  The automatically
+          * generated locations in write_end_info_ptr are wrong because we
+          * haven't written the end_info yet.
+          */
+         for (i = 0; i < (png_size_t)num_unknowns; i++)
+           png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
+             unknowns[i].location);
+      }
+   }
+#endif
+#ifdef PNG_WRITE_SUPPORTED
+   png_write_end(write_ptr, write_end_info_ptr);
+#endif
+
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+   if (verbose)
+   {
+      png_uint_32 iwidth, iheight;
+      iwidth = png_get_image_width(write_ptr, write_info_ptr);
+      iheight = png_get_image_height(write_ptr, write_info_ptr);
+      fprintf(STDERR, "\n Image width = %lu, height = %lu\n",
+         (unsigned long)iwidth, (unsigned long)iheight);
+   }
+#endif
+
+   png_debug(0, "Destroying data structs");
+#ifdef SINGLE_ROWBUF_ALLOC
+   png_debug(1, "destroying row_buf for read_ptr");
+   png_free(read_ptr, row_buf);
+   row_buf = NULL;
+#endif /* SINGLE_ROWBUF_ALLOC */
+   png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr");
+   png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
+#ifdef PNG_WRITE_SUPPORTED
+   png_debug(1, "destroying write_end_info_ptr");
+   png_destroy_info_struct(write_ptr, &write_end_info_ptr);
+   png_debug(1, "destroying write_ptr, write_info_ptr");
+   png_destroy_write_struct(&write_ptr, &write_info_ptr);
+#endif
+   png_debug(0, "Destruction complete.");
+
+   FCLOSE(fpin);
+   FCLOSE(fpout);
+
+   png_debug(0, "Opening files for comparison");
+   if ((fpin = fopen(inname, "rb")) == NULL)
+   {
+      fprintf(STDERR, "Could not find file %s\n", inname);
+      return (1);
+   }
+
+   if ((fpout = fopen(outname, "rb")) == NULL)
+   {
+      fprintf(STDERR, "Could not find file %s\n", outname);
+      FCLOSE(fpin);
+      return (1);
+   }
+
+   for (;;)
+   {
+      png_size_t num_in, num_out;
+
+         num_in = fread(inbuf, 1, 1, fpin);
+         num_out = fread(outbuf, 1, 1, fpout);
+
+      if (num_in != num_out)
+      {
+         fprintf(STDERR, "\nFiles %s and %s are of a different size\n",
+                 inname, outname);
+         if (wrote_question == 0)
+         {
+            fprintf(STDERR,
+         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",
+              inname, PNG_ZBUF_SIZE);
+            fprintf(STDERR,
+              "\n   filtering heuristic (libpng default), compression");
+            fprintf(STDERR,
+              " level (zlib default),\n   and zlib version (%s)?\n\n",
+              ZLIB_VERSION);
+            wrote_question = 1;
+         }
+         FCLOSE(fpin);
+         FCLOSE(fpout);
+         return (0);
+      }
+
+      if (!num_in)
+         break;
+
+      if (png_memcmp(inbuf, outbuf, num_in))
+      {
+         fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);
+         if (wrote_question == 0)
+         {
+            fprintf(STDERR,
+         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",
+                 inname, PNG_ZBUF_SIZE);
+            fprintf(STDERR,
+              "\n   filtering heuristic (libpng default), compression");
+            fprintf(STDERR,
+              " level (zlib default),\n   and zlib version (%s)?\n\n",
+              ZLIB_VERSION);
+            wrote_question = 1;
+         }
+         FCLOSE(fpin);
+         FCLOSE(fpout);
+         return (0);
+      }
+   }
+
+   FCLOSE(fpin);
+   FCLOSE(fpout);
+
+   return (0);
+}
+
+/* Input and output filenames */
+#ifdef RISCOS
+static PNG_CONST char *inname = "pngtest/png";
+static PNG_CONST char *outname = "pngout/png";
+#else
+static PNG_CONST char *inname = "pngtest.png";
+static PNG_CONST char *outname = "pngout.png";
+#endif
+
+int
+main(int argc, char *argv[])
+{
+   int multiple = 0;
+   int ierror = 0;
+
+   fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
+   fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);
+   fprintf(STDERR, "%s", png_get_copyright(NULL));
+   /* Show the version of libpng used in building the library */
+   fprintf(STDERR, " library (%lu):%s",
+      (unsigned long)png_access_version_number(),
+      png_get_header_version(NULL));
+   /* Show the version of libpng used in building the application */
+   fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,
+      PNG_HEADER_VERSION_STRING);
+   fprintf(STDERR, " sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n",
+                    (long)png_sizeof(png_struct), (long)png_sizeof(png_info));
+
+   /* 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
+    * tests should be impossible because of the way the macros are set
+    * in pngconf.h
+    */
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
+      fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
+#endif
+   /* I think the following can happen. */
+#if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
+      fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");
+#endif
+
+   if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
+   {
+      fprintf(STDERR,
+         "Warning: versions are different between png.h and png.c\n");
+      fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);
+      fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);
+      ++ierror;
+   }
+
+   if (argc > 1)
+   {
+      if (strcmp(argv[1], "-m") == 0)
+      {
+         multiple = 1;
+         status_dots_requested = 0;
+      }
+      else if (strcmp(argv[1], "-mv") == 0 ||
+               strcmp(argv[1], "-vm") == 0 )
+      {
+         multiple = 1;
+         verbose = 1;
+         status_dots_requested = 1;
+      }
+      else if (strcmp(argv[1], "-v") == 0)
+      {
+         verbose = 1;
+         status_dots_requested = 1;
+         inname = argv[2];
+      }
+      else
+      {
+         inname = argv[1];
+         status_dots_requested = 0;
+      }
+   }
+
+   if (!multiple && argc == 3 + verbose)
+     outname = argv[2 + verbose];
+
+   if ((!multiple && argc > 3 + verbose) || (multiple && argc < 2))
+   {
+     fprintf(STDERR,
+       "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
+        argv[0], argv[0]);
+     fprintf(STDERR,
+       "  reads/writes one PNG file (without -m) or multiple files (-m)\n");
+     fprintf(STDERR,
+       "  with -m %s is used as a temporary file\n", outname);
+     exit(1);
+   }
+
+   if (multiple)
+   {
+      int i;
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+      int allocation_now = current_allocation;
+#endif
+      for (i=2; i<argc; ++i)
+      {
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+         int k;
+#endif
+         int kerror;
+         fprintf(STDERR, "\n Testing %s:", argv[i]);
+         kerror = test_one_file(argv[i], outname);
+         if (kerror == 0)
+         {
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+            fprintf(STDERR, "\n PASS (%lu zero samples)\n",
+               (unsigned long)zero_samples);
+#else
+            fprintf(STDERR, " PASS\n");
+#endif
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+            for (k = 0; k<256; k++)
+               if (filters_used[k])
+                  fprintf(STDERR, " Filter %d was used %lu times\n",
+                     k, (unsigned long)filters_used[k]);
+#endif
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+         if (tIME_chunk_present != 0)
+            fprintf(STDERR, " tIME = %s\n", tIME_string);
+         tIME_chunk_present = 0;
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+         }
+         else
+         {
+            fprintf(STDERR, " FAIL\n");
+            ierror += kerror;
+         }
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+         if (allocation_now != current_allocation)
+            fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
+               current_allocation - allocation_now);
+         if (current_allocation != 0)
+         {
+            memory_infop pinfo = pinformation;
+
+            fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
+               current_allocation);
+            while (pinfo != NULL)
+            {
+               fprintf(STDERR, " %lu bytes at %x\n",
+                 (unsigned long)pinfo->size,
+                 (unsigned int) pinfo->pointer);
+               pinfo = pinfo->next;
+            }
+         }
+#endif
+      }
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+         fprintf(STDERR, " Current memory allocation: %10d bytes\n",
+            current_allocation);
+         fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
+            maximum_allocation);
+         fprintf(STDERR, " Total   memory allocation: %10d bytes\n",
+            total_allocation);
+         fprintf(STDERR, "     Number of allocations: %10d\n",
+            num_allocations);
+#endif
+   }
+   else
+   {
+      int i;
+      for (i = 0; i<3; ++i)
+      {
+         int kerror;
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+         int allocation_now = current_allocation;
+#endif
+         if (i == 1) status_dots_requested = 1;
+         else if (verbose == 0)status_dots_requested = 0;
+         if (i == 0 || verbose == 1 || ierror != 0)
+            fprintf(STDERR, "\n Testing %s:", inname);
+         kerror = test_one_file(inname, outname);
+         if (kerror == 0)
+         {
+            if (verbose == 1 || i == 2)
+            {
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+                int k;
+#endif
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+                fprintf(STDERR, "\n PASS (%lu zero samples)\n",
+                   (unsigned long)zero_samples);
+#else
+                fprintf(STDERR, " PASS\n");
+#endif
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+                for (k = 0; k<256; k++)
+                   if (filters_used[k])
+                      fprintf(STDERR, " Filter %d was used %lu times\n",
+                         k,
+                         (unsigned long)filters_used[k]);
+#endif
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+             if (tIME_chunk_present != 0)
+                fprintf(STDERR, " tIME = %s\n", tIME_string);
+#endif /* PNG_TIME_RFC1123_SUPPORTED */
+            }
+         }
+         else
+         {
+            if (verbose == 0 && i != 2)
+               fprintf(STDERR, "\n Testing %s:", inname);
+            fprintf(STDERR, " FAIL\n");
+            ierror += kerror;
+         }
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+         if (allocation_now != current_allocation)
+             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
+               current_allocation - allocation_now);
+         if (current_allocation != 0)
+         {
+             memory_infop pinfo = pinformation;
+
+             fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
+                current_allocation);
+             while (pinfo != NULL)
+             {
+                fprintf(STDERR, " %lu bytes at %x\n",
+                   (unsigned long)pinfo->size, (unsigned int)pinfo->pointer);
+                pinfo = pinfo->next;
+             }
+          }
+#endif
+       }
+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+       fprintf(STDERR, " Current memory allocation: %10d bytes\n",
+          current_allocation);
+       fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
+          maximum_allocation);
+       fprintf(STDERR, " Total   memory allocation: %10d bytes\n",
+          total_allocation);
+       fprintf(STDERR, "     Number of allocations: %10d\n",
+            num_allocations);
+#endif
+   }
+
+#ifdef PNGTEST_TIMING
+   t_stop = (float)clock();
+   t_misc += (t_stop - t_start);
+   t_start = t_stop;
+   fprintf(STDERR, " CPU time used = %.3f seconds",
+      (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);
+   fprintf(STDERR, " (decoding %.3f,\n",
+      t_decode/(float)CLOCKS_PER_SEC);
+   fprintf(STDERR, "        encoding %.3f ,",
+      t_encode/(float)CLOCKS_PER_SEC);
+   fprintf(STDERR, " other %.3f seconds)\n\n",
+      t_misc/(float)CLOCKS_PER_SEC);
+#endif
+
+   if (ierror == 0)
+      fprintf(STDERR, " libpng passes test\n");
+   else
+      fprintf(STDERR, " libpng FAILS test\n");
+   return (int)(ierror != 0);
+}
+
+/* Generate a compiler error if there is an old png.h in the search path. */
+typedef version_1_4_0 your_png_h_is_not_version_1_4_0;
diff --git a/src/libpng/pngtrans.c b/src/libpng/pngtrans.c
index 2122839bc..7b217bb3b 100644
--- a/src/libpng/pngtrans.c
+++ b/src/libpng/pngtrans.c
@@ -1,699 +1,676 @@
-

-/* pngtrans.c - transforms the data in a row (used by both readers and writers)

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

-

-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

-/* Turn on BGR-to-RGB mapping */

-void PNGAPI

-png_set_bgr(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_bgr");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_BGR;

-}

-#endif

-

-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

-/* Turn on 16 bit byte swapping */

-void PNGAPI

-png_set_swap(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_swap");

-

-   if (png_ptr == NULL)

-      return;

-   if (png_ptr->bit_depth == 16)

-      png_ptr->transformations |= PNG_SWAP_BYTES;

-}

-#endif

-

-#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)

-/* Turn on pixel packing */

-void PNGAPI

-png_set_packing(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_packing");

-

-   if (png_ptr == NULL)

-      return;

-   if (png_ptr->bit_depth < 8)

-   {

-      png_ptr->transformations |= PNG_PACK;

-      png_ptr->usr_bit_depth = 8;

-   }

-}

-#endif

-

-#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)

-/* Turn on packed pixel swapping */

-void PNGAPI

-png_set_packswap(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_packswap");

-

-   if (png_ptr == NULL)

-      return;

-   if (png_ptr->bit_depth < 8)

-      png_ptr->transformations |= PNG_PACKSWAP;

-}

-#endif

-

-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

-void PNGAPI

-png_set_shift(png_structp png_ptr, png_color_8p true_bits)

-{

-   png_debug(1, "in png_set_shift");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_SHIFT;

-   png_ptr->shift = *true_bits;

-}

-#endif

-

-#if defined(PNG_READ_INTERLACING_SUPPORTED) || \

-    defined(PNG_WRITE_INTERLACING_SUPPORTED)

-int PNGAPI

-png_set_interlace_handling(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_interlace handling");

-

-   if (png_ptr && png_ptr->interlaced)

-   {

-      png_ptr->transformations |= PNG_INTERLACE;

-      return (7);

-   }

-

-   return (1);

-}

-#endif

-

-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

-/* Add a filler byte on read, or remove a filler or alpha byte on write.

- * The filler type has changed in v0.95 to allow future 2-byte fillers

- * for 48-bit input data, as well as to avoid problems with some compilers

- * that don't like bytes as parameters.

- */

-void PNGAPI

-png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)

-{

-   png_debug(1, "in png_set_filler");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_FILLER;

-#ifdef PNG_LEGACY_SUPPORTED

-   png_ptr->filler = (png_byte)filler;

-#else

-   png_ptr->filler = (png_uint_16)filler;

-#endif

-   if (filler_loc == PNG_FILLER_AFTER)

-      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;

-   else

-      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;

-

-   /* This should probably go in the "do_read_filler" routine.

-    * I attempted to do that in libpng-1.0.1a but that caused problems

-    * so I restored it in libpng-1.0.2a

-   */

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-   {

-      png_ptr->usr_channels = 4;

-   }

-

-   /* Also I added this in libpng-1.0.2a (what happens when we expand

-    * a less-than-8-bit grayscale to GA? */

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)

-   {

-      png_ptr->usr_channels = 2;

-   }

-}

-

-#ifndef PNG_1_0_X

-/* Added to libpng-1.2.7 */

-void PNGAPI

-png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)

-{

-   png_debug(1, "in png_set_add_alpha");

-

-   if (png_ptr == NULL)

-      return;

-   png_set_filler(png_ptr, filler, filler_loc);

-   png_ptr->transformations |= PNG_ADD_ALPHA;

-}

-#endif

-

-#endif

-

-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \

-    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

-void PNGAPI

-png_set_swap_alpha(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_swap_alpha");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_SWAP_ALPHA;

-}

-#endif

-

-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \

-    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

-void PNGAPI

-png_set_invert_alpha(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_invert_alpha");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_INVERT_ALPHA;

-}

-#endif

-

-#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

-void PNGAPI

-png_set_invert_mono(png_structp png_ptr)

-{

-   png_debug(1, "in png_set_invert_mono");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_INVERT_MONO;

-}

-

-/* Invert monochrome grayscale data */

-void /* PRIVATE */

-png_do_invert(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_invert");

-

-  /* This test removed from libpng version 1.0.13 and 1.2.0:

-   *   if (row_info->bit_depth == 1 &&

-   */

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row == NULL || row_info == NULL)

-     return;

-#endif

-   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->rowbytes;

-

-      for (i = 0; i < istop; i++)

-      {

-         *rp = (png_byte)(~(*rp));

-         rp++;

-      }

-   }

-   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

-      row_info->bit_depth == 8)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->rowbytes;

-

-      for (i = 0; i < istop; i+=2)

-      {

-         *rp = (png_byte)(~(*rp));

-         rp+=2;

-      }

-   }

-   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

-      row_info->bit_depth == 16)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->rowbytes;

-

-      for (i = 0; i < istop; i+=4)

-      {

-         *rp = (png_byte)(~(*rp));

-         *(rp+1) = (png_byte)(~(*(rp+1)));

-         rp+=4;

-      }

-   }

-}

-#endif

-

-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

-/* Swaps byte order on 16 bit depth images */

-void /* PRIVATE */

-png_do_swap(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_swap");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-       row_info->bit_depth == 16)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop= row_info->width * row_info->channels;

-

-      for (i = 0; i < istop; i++, rp += 2)

-      {

-         png_byte t = *rp;

-         *rp = *(rp + 1);

-         *(rp + 1) = t;

-      }

-   }

-}

-#endif

-

-#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)

-static PNG_CONST png_byte onebppswaptable[256] = {

-   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,

-   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,

-   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,

-   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,

-   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,

-   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,

-   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,

-   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,

-   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,

-   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,

-   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,

-   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,

-   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,

-   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,

-   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,

-   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,

-   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,

-   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,

-   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,

-   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,

-   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,

-   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,

-   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,

-   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,

-   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,

-   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,

-   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,

-   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,

-   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,

-   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,

-   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,

-   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF

-};

-

-static PNG_CONST png_byte twobppswaptable[256] = {

-   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,

-   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,

-   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,

-   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,

-   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,

-   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,

-   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,

-   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,

-   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,

-   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,

-   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,

-   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,

-   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,

-   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,

-   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,

-   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,

-   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,

-   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,

-   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,

-   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,

-   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,

-   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,

-   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,

-   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,

-   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,

-   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,

-   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,

-   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,

-   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,

-   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,

-   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,

-   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF

-};

-

-static PNG_CONST png_byte fourbppswaptable[256] = {

-   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,

-   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,

-   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,

-   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,

-   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,

-   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,

-   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,

-   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,

-   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,

-   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,

-   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,

-   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,

-   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,

-   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,

-   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,

-   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,

-   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,

-   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,

-   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,

-   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,

-   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,

-   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,

-   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,

-   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,

-   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,

-   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,

-   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,

-   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,

-   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,

-   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,

-   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,

-   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF

-};

-

-/* Swaps pixel packing order within bytes */

-void /* PRIVATE */

-png_do_packswap(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_packswap");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-       row_info->bit_depth < 8)

-   {

-      png_bytep rp, end, table;

-

-      end = row + row_info->rowbytes;

-

-      if (row_info->bit_depth == 1)

-         table = (png_bytep)onebppswaptable;

-      else if (row_info->bit_depth == 2)

-         table = (png_bytep)twobppswaptable;

-      else if (row_info->bit_depth == 4)

-         table = (png_bytep)fourbppswaptable;

-      else

-         return;

-

-      for (rp = row; rp < end; rp++)

-         *rp = table[*rp];

-   }

-}

-#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */

-

-#if defined(PNG_WRITE_FILLER_SUPPORTED) || \

-    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

-/* Remove filler or alpha byte(s) */

-void /* PRIVATE */

-png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)

-{

-   png_debug(1, "in png_do_strip_filler");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL)

-#endif

-   {

-      png_bytep sp=row;

-      png_bytep dp=row;

-      png_uint_32 row_width=row_info->width;

-      png_uint_32 i;

-

-      if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||

-          (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&

-          (flags & PNG_FLAG_STRIP_ALPHA))) &&

-          row_info->channels == 4)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            /* This converts from RGBX or RGBA to RGB */

-            if (flags & PNG_FLAG_FILLER_AFTER)

-            {

-               dp+=3; sp+=4;

-               for (i = 1; i < row_width; i++)

-               {

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  sp++;

-               }

-            }

-            /* This converts from XRGB or ARGB to RGB */

-            else

-            {

-               for (i = 0; i < row_width; i++)

-               {

-                  sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-               }

-            }

-            row_info->pixel_depth = 24;

-            row_info->rowbytes = row_width * 3;

-         }

-         else /* if (row_info->bit_depth == 16) */

-         {

-            if (flags & PNG_FLAG_FILLER_AFTER)

-            {

-               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */

-               sp += 8; dp += 6;

-               for (i = 1; i < row_width; i++)

-               {

-                  /* This could be (although png_memcpy is probably slower):

-                  png_memcpy(dp, sp, 6);

-                  sp += 8;

-                  dp += 6;

-                  */

-

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  sp += 2;

-               }

-            }

-            else

-            {

-               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */

-               for (i = 0; i < row_width; i++)

-               {

-                  /* This could be (although png_memcpy is probably slower):

-                  png_memcpy(dp, sp, 6);

-                  sp += 8;

-                  dp += 6;

-                  */

-

-                  sp+=2;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-               }

-            }

-            row_info->pixel_depth = 48;

-            row_info->rowbytes = row_width * 6;

-         }

-         row_info->channels = 3;

-      }

-      else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||

-         (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

-         (flags & PNG_FLAG_STRIP_ALPHA))) &&

-          row_info->channels == 2)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            /* This converts from GX or GA to G */

-            if (flags & PNG_FLAG_FILLER_AFTER)

-            {

-               for (i = 0; i < row_width; i++)

-               {

-                  *dp++ = *sp++;

-                  sp++;

-               }

-            }

-            /* This converts from XG or AG to G */

-            else

-            {

-               for (i = 0; i < row_width; i++)

-               {

-                  sp++;

-                  *dp++ = *sp++;

-               }

-            }

-            row_info->pixel_depth = 8;

-            row_info->rowbytes = row_width;

-         }

-         else /* if (row_info->bit_depth == 16) */

-         {

-            if (flags & PNG_FLAG_FILLER_AFTER)

-            {

-               /* This converts from GGXX or GGAA to GG */

-               sp += 4; dp += 2;

-               for (i = 1; i < row_width; i++)

-               {

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  sp += 2;

-               }

-            }

-            else

-            {

-               /* This converts from XXGG or AAGG to GG */

-               for (i = 0; i < row_width; i++)

-               {

-                  sp += 2;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-               }

-            }

-            row_info->pixel_depth = 16;

-            row_info->rowbytes = row_width * 2;

-         }

-         row_info->channels = 1;

-      }

-      if (flags & PNG_FLAG_STRIP_ALPHA)

-        row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

-   }

-}

-#endif

-

-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

-/* Swaps red and blue bytes within a pixel */

-void /* PRIVATE */

-png_do_bgr(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_bgr");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-       (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      png_uint_32 row_width = row_info->width;

-      if (row_info->bit_depth == 8)

-      {

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 3)

-            {

-               png_byte save = *rp;

-               *rp = *(rp + 2);

-               *(rp + 2) = save;

-            }

-         }

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 4)

-            {

-               png_byte save = *rp;

-               *rp = *(rp + 2);

-               *(rp + 2) = save;

-            }

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 6)

-            {

-               png_byte save = *rp;

-               *rp = *(rp + 4);

-               *(rp + 4) = save;

-               save = *(rp + 1);

-               *(rp + 1) = *(rp + 5);

-               *(rp + 5) = save;

-            }

-         }

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 8)

-            {

-               png_byte save = *rp;

-               *rp = *(rp + 4);

-               *(rp + 4) = save;

-               save = *(rp + 1);

-               *(rp + 1) = *(rp + 5);

-               *(rp + 5) = save;

-            }

-         }

-      }

-   }

-}

-#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */

-

-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

-    defined(PNG_LEGACY_SUPPORTED) || \

-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

-void PNGAPI

-png_set_user_transform_info(png_structp png_ptr, png_voidp

-   user_transform_ptr, int user_transform_depth, int user_transform_channels)

-{

-   png_debug(1, "in png_set_user_transform_info");

-

-   if (png_ptr == NULL)

-      return;

-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

-   png_ptr->user_transform_ptr = user_transform_ptr;

-   png_ptr->user_transform_depth = (png_byte)user_transform_depth;

-   png_ptr->user_transform_channels = (png_byte)user_transform_channels;

-#else

-   if (user_transform_ptr || user_transform_depth || user_transform_channels)

-      png_warning(png_ptr,

-        "This version of libpng does not support user transform info");

-#endif

-}

-#endif

-

-/* This function returns a pointer to the user_transform_ptr associated with

- * the user transform functions.  The application should free any memory

- * associated with this pointer before png_write_destroy and png_read_destroy

- * are called.

- */

-png_voidp PNGAPI

-png_get_user_transform_ptr(png_structp png_ptr)

-{

-   if (png_ptr == NULL)

-      return (NULL);

-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

-   return ((png_voidp)png_ptr->user_transform_ptr);

-#else

-   return (NULL);

-#endif

-}

-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

+
+/* pngtrans.c - transforms the data in a row (used by both readers and writers)
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#include "pngpriv.h"
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* Turn on BGR-to-RGB mapping */
+void PNGAPI
+png_set_bgr(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_bgr");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_BGR;
+}
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* Turn on 16 bit byte swapping */
+void PNGAPI
+png_set_swap(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_swap");
+
+   if (png_ptr == NULL)
+      return;
+   if (png_ptr->bit_depth == 16)
+      png_ptr->transformations |= PNG_SWAP_BYTES;
+}
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+/* Turn on pixel packing */
+void PNGAPI
+png_set_packing(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_packing");
+
+   if (png_ptr == NULL)
+      return;
+   if (png_ptr->bit_depth < 8)
+   {
+      png_ptr->transformations |= PNG_PACK;
+      png_ptr->usr_bit_depth = 8;
+   }
+}
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+/* Turn on packed pixel swapping */
+void PNGAPI
+png_set_packswap(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_packswap");
+
+   if (png_ptr == NULL)
+      return;
+   if (png_ptr->bit_depth < 8)
+      png_ptr->transformations |= PNG_PACKSWAP;
+}
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+void PNGAPI
+png_set_shift(png_structp png_ptr, png_color_8p true_bits)
+{
+   png_debug(1, "in png_set_shift");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_SHIFT;
+   png_ptr->shift = *true_bits;
+}
+#endif
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+    defined(PNG_WRITE_INTERLACING_SUPPORTED)
+int PNGAPI
+png_set_interlace_handling(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_interlace handling");
+
+   if (png_ptr && png_ptr->interlaced)
+   {
+      png_ptr->transformations |= PNG_INTERLACE;
+      return (7);
+   }
+
+   return (1);
+}
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+/* Add a filler byte on read, or remove a filler or alpha byte on write.
+ * The filler type has changed in v0.95 to allow future 2-byte fillers
+ * for 48-bit input data, as well as to avoid problems with some compilers
+ * that don't like bytes as parameters.
+ */
+void PNGAPI
+png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
+{
+   png_debug(1, "in png_set_filler");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_FILLER;
+   png_ptr->filler = (png_uint_16)filler;
+   if (filler_loc == PNG_FILLER_AFTER)
+      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
+   else
+      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
+
+   /* This should probably go in the "do_read_filler" routine.
+    * I attempted to do that in libpng-1.0.1a but that caused problems
+    * so I restored it in libpng-1.0.2a
+   */
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+   {
+      png_ptr->usr_channels = 4;
+   }
+
+   /* Also I added this in libpng-1.0.2a (what happens when we expand
+    * a less-than-8-bit grayscale to GA? */
+
+   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
+   {
+      png_ptr->usr_channels = 2;
+   }
+}
+
+/* Added to libpng-1.2.7 */
+void PNGAPI
+png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
+{
+   png_debug(1, "in png_set_add_alpha");
+
+   if (png_ptr == NULL)
+      return;
+   png_set_filler(png_ptr, filler, filler_loc);
+   png_ptr->transformations |= PNG_ADD_ALPHA;
+}
+
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+void PNGAPI
+png_set_swap_alpha(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_swap_alpha");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_SWAP_ALPHA;
+}
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+void PNGAPI
+png_set_invert_alpha(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_invert_alpha");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_INVERT_ALPHA;
+}
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+void PNGAPI
+png_set_invert_mono(png_structp png_ptr)
+{
+   png_debug(1, "in png_set_invert_mono");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_INVERT_MONO;
+}
+
+/* Invert monochrome grayscale data */
+void /* PRIVATE */
+png_do_invert(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_invert");
+
+  /* This test removed from libpng version 1.0.13 and 1.2.0:
+   *   if (row_info->bit_depth == 1 &&
+   */
+   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+   {
+      png_bytep rp = row;
+      png_uint_32 i;
+      png_uint_32 istop = row_info->rowbytes;
+
+      for (i = 0; i < istop; i++)
+      {
+         *rp = (png_byte)(~(*rp));
+         rp++;
+      }
+   }
+   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
+      row_info->bit_depth == 8)
+   {
+      png_bytep rp = row;
+      png_uint_32 i;
+      png_uint_32 istop = row_info->rowbytes;
+
+      for (i = 0; i < istop; i+=2)
+      {
+         *rp = (png_byte)(~(*rp));
+         rp+=2;
+      }
+   }
+   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
+      row_info->bit_depth == 16)
+   {
+      png_bytep rp = row;
+      png_uint_32 i;
+      png_uint_32 istop = row_info->rowbytes;
+
+      for (i = 0; i < istop; i+=4)
+      {
+         *rp = (png_byte)(~(*rp));
+         *(rp+1) = (png_byte)(~(*(rp+1)));
+         rp+=4;
+      }
+   }
+}
+#endif
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* Swaps byte order on 16 bit depth images */
+void /* PRIVATE */
+png_do_swap(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_swap");
+
+   if (
+       row_info->bit_depth == 16)
+   {
+      png_bytep rp = row;
+      png_uint_32 i;
+      png_uint_32 istop= row_info->width * row_info->channels;
+
+      for (i = 0; i < istop; i++, rp += 2)
+      {
+         png_byte t = *rp;
+         *rp = *(rp + 1);
+         *(rp + 1) = t;
+      }
+   }
+}
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+static PNG_CONST png_byte onebppswaptable[256] = {
+   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
+   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
+   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
+   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
+   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
+   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
+   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
+   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
+   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
+   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
+   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
+   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
+   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
+   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
+   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
+   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
+   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
+   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
+   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
+   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
+   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
+   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
+   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
+   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
+   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
+   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
+   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
+   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
+   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
+   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
+   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
+};
+
+static PNG_CONST png_byte twobppswaptable[256] = {
+   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
+   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
+   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
+   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
+   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
+   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
+   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
+   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
+   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
+   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
+   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
+   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
+   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
+   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
+   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
+   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
+   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
+   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
+   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
+   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
+   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
+   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
+   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
+   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
+   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
+   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
+   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
+   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
+   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
+   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
+   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
+   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
+};
+
+static PNG_CONST png_byte fourbppswaptable[256] = {
+   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
+   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
+   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
+   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
+   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
+   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
+   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
+   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
+   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
+   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
+   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
+   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
+   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
+   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
+   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
+   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
+   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
+   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
+   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
+   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
+   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
+   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
+   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
+   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
+   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
+   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
+   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
+   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
+   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
+   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
+   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
+   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
+};
+
+/* Swaps pixel packing order within bytes */
+void /* PRIVATE */
+png_do_packswap(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_packswap");
+
+   if (
+       row_info->bit_depth < 8)
+   {
+      png_bytep rp, end, table;
+
+      end = row + row_info->rowbytes;
+
+      if (row_info->bit_depth == 1)
+         table = (png_bytep)onebppswaptable;
+      else if (row_info->bit_depth == 2)
+         table = (png_bytep)twobppswaptable;
+      else if (row_info->bit_depth == 4)
+         table = (png_bytep)fourbppswaptable;
+      else
+         return;
+
+      for (rp = row; rp < end; rp++)
+         *rp = table[*rp];
+   }
+}
+#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
+
+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
+    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+/* Remove filler or alpha byte(s) */
+void /* PRIVATE */
+png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
+{
+   png_debug(1, "in png_do_strip_filler");
+
+   {
+      png_bytep sp=row;
+      png_bytep dp=row;
+      png_uint_32 row_width=row_info->width;
+      png_uint_32 i;
+
+      if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
+          (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
+          (flags & PNG_FLAG_STRIP_ALPHA))) &&
+          row_info->channels == 4)
+      {
+         if (row_info->bit_depth == 8)
+         {
+            /* This converts from RGBX or RGBA to RGB */
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               dp+=3; sp+=4;
+               for (i = 1; i < row_width; i++)
+               {
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  sp++;
+               }
+            }
+            /* This converts from XRGB or ARGB to RGB */
+            else
+            {
+               for (i = 0; i < row_width; i++)
+               {
+                  sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 24;
+            row_info->rowbytes = row_width * 3;
+         }
+         else /* if (row_info->bit_depth == 16) */
+         {
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
+               sp += 8; dp += 6;
+               for (i = 1; i < row_width; i++)
+               {
+                  /* This could be (although png_memcpy is probably slower):
+                  png_memcpy(dp, sp, 6);
+                  sp += 8;
+                  dp += 6;
+                  */
+
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  sp += 2;
+               }
+            }
+            else
+            {
+               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
+               for (i = 0; i < row_width; i++)
+               {
+                  /* This could be (although png_memcpy is probably slower):
+                  png_memcpy(dp, sp, 6);
+                  sp += 8;
+                  dp += 6;
+                  */
+
+                  sp+=2;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 48;
+            row_info->rowbytes = row_width * 6;
+         }
+         row_info->channels = 3;
+      }
+      else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||
+         (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
+         (flags & PNG_FLAG_STRIP_ALPHA))) &&
+          row_info->channels == 2)
+      {
+         if (row_info->bit_depth == 8)
+         {
+            /* This converts from GX or GA to G */
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               for (i = 0; i < row_width; i++)
+               {
+                  *dp++ = *sp++;
+                  sp++;
+               }
+            }
+            /* This converts from XG or AG to G */
+            else
+            {
+               for (i = 0; i < row_width; i++)
+               {
+                  sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 8;
+            row_info->rowbytes = row_width;
+         }
+         else /* if (row_info->bit_depth == 16) */
+         {
+            if (flags & PNG_FLAG_FILLER_AFTER)
+            {
+               /* This converts from GGXX or GGAA to GG */
+               sp += 4; dp += 2;
+               for (i = 1; i < row_width; i++)
+               {
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+                  sp += 2;
+               }
+            }
+            else
+            {
+               /* This converts from XXGG or AAGG to GG */
+               for (i = 0; i < row_width; i++)
+               {
+                  sp += 2;
+                  *dp++ = *sp++;
+                  *dp++ = *sp++;
+               }
+            }
+            row_info->pixel_depth = 16;
+            row_info->rowbytes = row_width * 2;
+         }
+         row_info->channels = 1;
+      }
+      if (flags & PNG_FLAG_STRIP_ALPHA)
+        row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
+   }
+}
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* Swaps red and blue bytes within a pixel */
+void /* PRIVATE */
+png_do_bgr(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_bgr");
+
+   if (
+       (row_info->color_type & PNG_COLOR_MASK_COLOR))
+   {
+      png_uint_32 row_width = row_info->width;
+      if (row_info->bit_depth == 8)
+      {
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 3)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 2);
+               *(rp + 2) = save;
+            }
+         }
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 4)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 2);
+               *(rp + 2) = save;
+            }
+         }
+      }
+      else if (row_info->bit_depth == 16)
+      {
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 6)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 4);
+               *(rp + 4) = save;
+               save = *(rp + 1);
+               *(rp + 1) = *(rp + 5);
+               *(rp + 5) = save;
+            }
+         }
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+         {
+            png_bytep rp;
+            png_uint_32 i;
+
+            for (i = 0, rp = row; i < row_width; i++, rp += 8)
+            {
+               png_byte save = *rp;
+               *rp = *(rp + 4);
+               *(rp + 4) = save;
+               save = *(rp + 1);
+               *(rp + 1) = *(rp + 5);
+               *(rp + 5) = save;
+            }
+         }
+      }
+   }
+}
+#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+void PNGAPI
+png_set_user_transform_info(png_structp png_ptr, png_voidp
+   user_transform_ptr, int user_transform_depth, int user_transform_channels)
+{
+   png_debug(1, "in png_set_user_transform_info");
+
+   if (png_ptr == NULL)
+      return;
+#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+   png_ptr->user_transform_ptr = user_transform_ptr;
+   png_ptr->user_transform_depth = (png_byte)user_transform_depth;
+   png_ptr->user_transform_channels = (png_byte)user_transform_channels;
+#else
+   if (user_transform_ptr || user_transform_depth || user_transform_channels)
+      png_warning(png_ptr,
+        "This version of libpng does not support user transform info");
+#endif
+}
+#endif
+
+/* This function returns a pointer to the user_transform_ptr associated with
+ * the user transform functions.  The application should free any memory
+ * associated with this pointer before png_write_destroy and png_read_destroy
+ * are called.
+ */
+png_voidp PNGAPI
+png_get_user_transform_ptr(png_structp png_ptr)
+{
+   if (png_ptr == NULL)
+      return (NULL);
+#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+   return ((png_voidp)png_ptr->user_transform_ptr);
+#else
+   return (NULL);
+#endif
+}
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pngwio.c b/src/libpng/pngwio.c
index 6d771835d..f4d995b18 100644
--- a/src/libpng/pngwio.c
+++ b/src/libpng/pngwio.c
@@ -1,260 +1,241 @@
-

-/* pngwio.c - functions for data output

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- *

- * This file provides a location for all output.  Users who need

- * special handling are expected to write functions that have the same

- * arguments as these and perform similar functions, but that possibly

- * use different output methods.  Note that you shouldn't change these

- * functions, but rather write replacement functions and then change

- * them at run time with png_set_write_fn(...).

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_WRITE_SUPPORTED

-

-/* Write the data to whatever output you are using.  The default routine

- * writes to a file pointer.  Note that this routine sometimes gets called

- * with very small lengths, so you should implement some kind of simple

- * buffering if you are using unbuffered writes.  This should never be asked

- * to write more than 64K on a 16 bit machine.

- */

-

-void /* PRIVATE */

-png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   if (png_ptr->write_data_fn != NULL )

-      (*(png_ptr->write_data_fn))(png_ptr, data, length);

-   else

-      png_error(png_ptr, "Call to NULL write function");

-}

-

-#ifdef PNG_STDIO_SUPPORTED

-/* 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

- * write_data function and use it at run time with png_set_write_fn(), rather

- * than changing the library.

- */

-#ifndef USE_FAR_KEYWORD

-void PNGAPI

-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   png_uint_32 check;

-

-   if (png_ptr == NULL)

-      return;

-#ifdef _WIN32_WCE

-   if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )

-      check = 0;

-#else

-   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));

-#endif

-   if (check != length)

-      png_error(png_ptr, "Write Error");

-}

-#else

-/* This is the model-independent version. Since the standard I/O library

- * can't handle far buffers in the medium and small models, we have to copy

- * the data.

- */

-

-#define NEAR_BUF_SIZE 1024

-#define MIN(a,b) (a <= b ? a : b)

-

-void PNGAPI

-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   png_uint_32 check;

-   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

-   png_FILE_p io_ptr;

-

-   if (png_ptr == NULL)

-      return;

-   /* Check if data really is near. If so, use usual code. */

-   near_data = (png_byte *)CVT_PTR_NOCHECK(data);

-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

-   if ((png_bytep)near_data == data)

-   {

-#ifdef _WIN32_WCE

-      if ( !WriteFile(io_ptr, near_data, length, &check, NULL) )

-         check = 0;

-#else

-      check = fwrite(near_data, 1, length, io_ptr);

-#endif

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t written, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         written = MIN(NEAR_BUF_SIZE, remaining);

-         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */

-#ifdef _WIN32_WCE

-         if ( !WriteFile(io_ptr, buf, written, &err, NULL) )

-            err = 0;

-#else

-         err = fwrite(buf, 1, written, io_ptr);

-#endif

-         if (err != written)

-            break;

-

-         else

-            check += err;

-

-         data += written;

-         remaining -= written;

-      }

-      while (remaining != 0);

-   }

-   if (check != length)

-      png_error(png_ptr, "Write Error");

-}

-

-#endif

-#endif

-

-/* This function is called to output any data pending writing (normally

- * to disk).  After png_flush is called, there should be no data pending

- * writing in any buffers.

- */

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-void /* PRIVATE */

-png_flush(png_structp png_ptr)

-{

-   if (png_ptr->output_flush_fn != NULL)

-      (*(png_ptr->output_flush_fn))(png_ptr);

-}

-

-#ifdef PNG_STDIO_SUPPORTED

-void PNGAPI

-png_default_flush(png_structp png_ptr)

-{

-#ifndef _WIN32_WCE

-   png_FILE_p io_ptr;

-#endif

-   if (png_ptr == NULL)

-      return;

-#ifndef _WIN32_WCE

-   io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));

-   fflush(io_ptr);

-#endif

-}

-#endif

-#endif

-

-/* This function allows the application to supply new output functions for

- * libpng if standard C streams aren't being used.

- *

- * This function takes as its arguments:

- * png_ptr       - pointer to a png output data structure

- * io_ptr        - pointer to user supplied structure containing info about

- *                 the output functions.  May be NULL.

- * write_data_fn - pointer to a new output function that takes as its

- *                 arguments a pointer to a png_struct, a pointer to

- *                 data to be written, and a 32-bit unsigned int that is

- *                 the number of bytes to be written.  The new write

- *                 function should call png_error(png_ptr, "Error msg")

- *                 to exit and output any fatal error messages.  May be

- *                 NULL, in which case libpng's default function will

- *                 be used.

- * flush_data_fn - pointer to a new flush function that takes as its

- *                 arguments a pointer to a png_struct.  After a call to

- *                 the flush function, there should be no data in any buffers

- *                 or pending transmission.  If the output method doesn't do

- *                 any buffering of ouput, a function prototype must still be

- *                 supplied although it doesn't have to do anything.  If

- *                 PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile

- *                 time, output_flush_fn will be ignored, although it must be

- *                 supplied for compatibility.  May be NULL, in which case

- *                 libpng's default function will be used, if

- *                 PNG_WRITE_FLUSH_SUPPORTED is defined.  This is not

- *                 a good idea if io_ptr does not point to a standard

- *                 *FILE structure.

- */

-void PNGAPI

-png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,

-   png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)

-{

-   if (png_ptr == NULL)

-      return;

-

-   png_ptr->io_ptr = io_ptr;

-

-#ifdef PNG_STDIO_SUPPORTED

-   if (write_data_fn != NULL)

-      png_ptr->write_data_fn = write_data_fn;

-

-   else

-      png_ptr->write_data_fn = png_default_write_data;

-#else

-   png_ptr->write_data_fn = write_data_fn;

-#endif

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-#ifdef PNG_STDIO_SUPPORTED

-   if (output_flush_fn != NULL)

-      png_ptr->output_flush_fn = output_flush_fn;

-

-   else

-      png_ptr->output_flush_fn = png_default_flush;

-#else

-   png_ptr->output_flush_fn = output_flush_fn;

-#endif

-#endif /* PNG_WRITE_FLUSH_SUPPORTED */

-

-   /* It is an error to read while writing a png file */

-   if (png_ptr->read_data_fn != NULL)

-   {

-      png_ptr->read_data_fn = NULL;

-      png_warning(png_ptr,

-         "Attempted to set both read_data_fn and write_data_fn in");

-      png_warning(png_ptr,

-         "the same structure.  Resetting read_data_fn to NULL.");

-   }

-}

-

-#ifdef USE_FAR_KEYWORD

-#ifdef _MSC_VER

-void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)

-{

-   void *near_ptr;

-   void FAR *far_ptr;

-   FP_OFF(near_ptr) = FP_OFF(ptr);

-   far_ptr = (void FAR *)near_ptr;

-

-   if (check != 0)

-      if (FP_SEG(ptr) != FP_SEG(far_ptr))

-         png_error(png_ptr, "segment lost in conversion");

-

-   return(near_ptr);

-}

-#  else

-void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)

-{

-   void *near_ptr;

-   void FAR *far_ptr;

-   near_ptr = (void FAR *)ptr;

-   far_ptr = (void FAR *)near_ptr;

-

-   if (check != 0)

-      if (far_ptr != ptr)

-         png_error(png_ptr, "segment lost in conversion");

-

-   return(near_ptr);

-}

-#   endif

-#   endif

-#endif /* PNG_WRITE_SUPPORTED */

+
+/* pngwio.c - functions for data output
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all output.  Users who need
+ * special handling are expected to write functions that have the same
+ * arguments as these and perform similar functions, but that possibly
+ * use different output methods.  Note that you shouldn't change these
+ * functions, but rather write replacement functions and then change
+ * them at run time with png_set_write_fn(...).
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+#include "pngpriv.h"
+
+/* Write the data to whatever output you are using.  The default routine
+ * writes to a file pointer.  Note that this routine sometimes gets called
+ * with very small lengths, so you should implement some kind of simple
+ * buffering if you are using unbuffered writes.  This should never be asked
+ * to write more than 64K on a 16 bit machine.
+ */
+
+void /* PRIVATE */
+png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   if (png_ptr->write_data_fn != NULL )
+      (*(png_ptr->write_data_fn))(png_ptr, data, length);
+   else
+      png_error(png_ptr, "Call to NULL write function");
+}
+
+#ifdef PNG_STDIO_SUPPORTED
+/* 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
+ * write_data function and use it at run time with png_set_write_fn(), rather
+ * than changing the library.
+ */
+#ifndef USE_FAR_KEYWORD
+void PNGAPI
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_uint_32 check;
+
+   if (png_ptr == NULL)
+      return;
+   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
+   if (check != length)
+      png_error(png_ptr, "Write Error");
+}
+#else
+/* This is the model-independent version. Since the standard I/O library
+ * can't handle far buffers in the medium and small models, we have to copy
+ * the data.
+ */
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+void PNGAPI
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_uint_32 check;
+   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */
+   png_FILE_p io_ptr;
+
+   if (png_ptr == NULL)
+      return;
+   /* Check if data really is near. If so, use usual code. */
+   near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)near_data == data)
+   {
+      check = fwrite(near_data, 1, length, io_ptr);
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t written, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         written = MIN(NEAR_BUF_SIZE, remaining);
+         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
+         err = fwrite(buf, 1, written, io_ptr);
+         if (err != written)
+            break;
+
+         else
+            check += err;
+
+         data += written;
+         remaining -= written;
+      }
+      while (remaining != 0);
+   }
+   if (check != length)
+      png_error(png_ptr, "Write Error");
+}
+
+#endif
+#endif
+
+/* This function is called to output any data pending writing (normally
+ * to disk).  After png_flush is called, there should be no data pending
+ * writing in any buffers.
+ */
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+void /* PRIVATE */
+png_flush(png_structp png_ptr)
+{
+   if (png_ptr->output_flush_fn != NULL)
+      (*(png_ptr->output_flush_fn))(png_ptr);
+}
+
+#ifdef PNG_STDIO_SUPPORTED
+void PNGAPI
+png_default_flush(png_structp png_ptr)
+{
+   png_FILE_p io_ptr;
+   if (png_ptr == NULL)
+      return;
+   io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
+   fflush(io_ptr);
+}
+#endif
+#endif
+
+/* This function allows the application to supply new output functions for
+ * libpng if standard C streams aren't being used.
+ *
+ * This function takes as its arguments:
+ * png_ptr       - pointer to a png output data structure
+ * io_ptr        - pointer to user supplied structure containing info about
+ *                 the output functions.  May be NULL.
+ * write_data_fn - pointer to a new output function that takes as its
+ *                 arguments a pointer to a png_struct, a pointer to
+ *                 data to be written, and a 32-bit unsigned int that is
+ *                 the number of bytes to be written.  The new write
+ *                 function should call png_error(png_ptr, "Error msg")
+ *                 to exit and output any fatal error messages.  May be
+ *                 NULL, in which case libpng's default function will
+ *                 be used.
+ * flush_data_fn - pointer to a new flush function that takes as its
+ *                 arguments a pointer to a png_struct.  After a call to
+ *                 the flush function, there should be no data in any buffers
+ *                 or pending transmission.  If the output method doesn't do
+ *                 any buffering of ouput, a function prototype must still be
+ *                 supplied although it doesn't have to do anything.  If
+ *                 PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
+ *                 time, output_flush_fn will be ignored, although it must be
+ *                 supplied for compatibility.  May be NULL, in which case
+ *                 libpng's default function will be used, if
+ *                 PNG_WRITE_FLUSH_SUPPORTED is defined.  This is not
+ *                 a good idea if io_ptr does not point to a standard
+ *                 *FILE structure.
+ */
+void PNGAPI
+png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
+   png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
+{
+   if (png_ptr == NULL)
+      return;
+
+   png_ptr->io_ptr = io_ptr;
+
+#ifdef PNG_STDIO_SUPPORTED
+   if (write_data_fn != NULL)
+      png_ptr->write_data_fn = write_data_fn;
+
+   else
+      png_ptr->write_data_fn = png_default_write_data;
+#else
+   png_ptr->write_data_fn = write_data_fn;
+#endif
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+#ifdef PNG_STDIO_SUPPORTED
+   if (output_flush_fn != NULL)
+      png_ptr->output_flush_fn = output_flush_fn;
+
+   else
+      png_ptr->output_flush_fn = png_default_flush;
+#else
+   png_ptr->output_flush_fn = output_flush_fn;
+#endif
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+
+   /* It is an error to read while writing a png file */
+   if (png_ptr->read_data_fn != NULL)
+   {
+      png_ptr->read_data_fn = NULL;
+      png_warning(png_ptr,
+         "Attempted to set both read_data_fn and write_data_fn in");
+      png_warning(png_ptr,
+         "the same structure.  Resetting read_data_fn to NULL");
+   }
+}
+
+#ifdef USE_FAR_KEYWORD
+#ifdef _MSC_VER
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+{
+   void *near_ptr;
+   void FAR *far_ptr;
+   FP_OFF(near_ptr) = FP_OFF(ptr);
+   far_ptr = (void FAR *)near_ptr;
+
+   if (check != 0)
+      if (FP_SEG(ptr) != FP_SEG(far_ptr))
+         png_error(png_ptr, "segment lost in conversion");
+
+   return(near_ptr);
+}
+#  else
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+{
+   void *near_ptr;
+   void FAR *far_ptr;
+   near_ptr = (void FAR *)ptr;
+   far_ptr = (void FAR *)near_ptr;
+
+   if (check != 0)
+      if (far_ptr != ptr)
+         png_error(png_ptr, "segment lost in conversion");
+
+   return(near_ptr);
+}
+#   endif
+#   endif
+#endif /* PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pngwrite.c b/src/libpng/pngwrite.c
index a254f1812..01a7f60e5 100644
--- a/src/libpng/pngwrite.c
+++ b/src/libpng/pngwrite.c
@@ -1,1585 +1,1454 @@
-

-/* pngwrite.c - general routines to write a PNG file

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- */

-

-/* Get internal access to png.h */

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_WRITE_SUPPORTED

-

-/* Writes all the PNG information.  This is the suggested way to use the

- * library.  If you have a new chunk to add, make a function to write it,

- * and put it in the correct location here.  If you want the chunk written

- * after the image data, put it in png_write_end().  I strongly encourage

- * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing

- * the chunk, as that will keep the code from breaking if you want to just

- * write a plain PNG file.  If you have long comments, I suggest writing

- * them in png_write_end(), and compressing them.

- */

-void PNGAPI

-png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)

-{

-   png_debug(1, "in png_write_info_before_PLTE");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-   if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))

-   {

-   /* Write PNG signature */

-   png_write_sig(png_ptr);

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))

-   {

-      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");

-      png_ptr->mng_features_permitted = 0;

-   }

-#endif

-   /* Write IHDR information. */

-   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->filter_type,

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-      info_ptr->interlace_type);

-#else

-      0);

-#endif

-   /* The rest of these check to see if the valid field has the appropriate

-    * flag set, and if it does, writes the chunk.

-    */

-#ifdef PNG_WRITE_gAMA_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_gAMA)

-   {

-#  ifdef PNG_FLOATING_POINT_SUPPORTED

-      png_write_gAMA(png_ptr, info_ptr->gamma);

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-      png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);

-#  endif

-#endif

-   }

-#endif

-#ifdef PNG_WRITE_sRGB_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_sRGB)

-      png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);

-#endif

-#ifdef PNG_WRITE_iCCP_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_iCCP)

-      png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,

-                     info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);

-#endif

-#ifdef PNG_WRITE_sBIT_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_sBIT)

-      png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);

-#endif

-#ifdef PNG_WRITE_cHRM_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_cHRM)

-   {

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-      png_write_cHRM(png_ptr,

-         info_ptr->x_white, info_ptr->y_white,

-         info_ptr->x_red, info_ptr->y_red,

-         info_ptr->x_green, info_ptr->y_green,

-         info_ptr->x_blue, info_ptr->y_blue);

-#else

-#  ifdef PNG_FIXED_POINT_SUPPORTED

-      png_write_cHRM_fixed(png_ptr,

-         info_ptr->int_x_white, info_ptr->int_y_white,

-         info_ptr->int_x_red, info_ptr->int_y_red,

-         info_ptr->int_x_green, info_ptr->int_y_green,

-         info_ptr->int_x_blue, info_ptr->int_y_blue);

-#  endif

-#endif

-   }

-#endif

-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   if (info_ptr->unknown_chunks_num)

-   {

-      png_unknown_chunk *up;

-

-      png_debug(5, "writing extra chunks");

-

-      for (up = info_ptr->unknown_chunks;

-           up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;

-           up++)

-      {

-         int keep = png_handle_as_unknown(png_ptr, up->name);

-         if (keep != PNG_HANDLE_CHUNK_NEVER &&

-            up->location && !(up->location & PNG_HAVE_PLTE) &&

-            !(up->location & PNG_HAVE_IDAT) &&

-            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

-            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

-         {

-            if (up->size == 0)

-               png_warning(png_ptr, "Writing zero-length unknown chunk");

-            png_write_chunk(png_ptr, up->name, up->data, up->size);

-         }

-      }

-   }

-#endif

-      png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;

-   }

-}

-

-void PNGAPI

-png_write_info(png_structp png_ptr, png_infop info_ptr)

-{

-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

-   int i;

-#endif

-

-   png_debug(1, "in png_write_info");

-

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   png_write_info_before_PLTE(png_ptr, info_ptr);

-

-   if (info_ptr->valid & PNG_INFO_PLTE)

-      png_write_PLTE(png_ptr, info_ptr->palette,

-         (png_uint_32)info_ptr->num_palette);

-   else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      png_error(png_ptr, "Valid palette required for paletted images");

-

-#ifdef PNG_WRITE_tRNS_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_tRNS)

-   {

-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-      /* Invert the alpha channel (in tRNS) */

-      if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&

-         info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         int j;

-         for (j = 0; j<(int)info_ptr->num_trans; j++)

-            info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);

-      }

-#endif

-      png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),

-         info_ptr->num_trans, info_ptr->color_type);

-   }

-#endif

-#ifdef PNG_WRITE_bKGD_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_bKGD)

-      png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);

-#endif

-#ifdef PNG_WRITE_hIST_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_hIST)

-      png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);

-#endif

-#ifdef PNG_WRITE_oFFs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_oFFs)

-      png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,

-         info_ptr->offset_unit_type);

-#endif

-#ifdef PNG_WRITE_pCAL_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pCAL)

-      png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,

-         info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,

-         info_ptr->pcal_units, info_ptr->pcal_params);

-#endif

-

-#ifdef PNG_sCAL_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_sCAL)

-#ifdef PNG_WRITE_sCAL_SUPPORTED

-#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)

-      png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,

-          info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);

-#else /* !FLOATING_POINT */

-#ifdef PNG_FIXED_POINT_SUPPORTED

-      png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,

-          info_ptr->scal_s_width, info_ptr->scal_s_height);

-#endif /* FIXED_POINT */

-#endif /* FLOATING_POINT */

-#else  /* !WRITE_sCAL */

-      png_warning(png_ptr,

-          "png_write_sCAL not supported; sCAL chunk not written.");

-#endif /* WRITE_sCAL */

-#endif /* sCAL */

-

-#ifdef PNG_WRITE_pHYs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pHYs)

-      png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,

-         info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);

-#endif /* pHYs */

-

-#ifdef PNG_WRITE_tIME_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_tIME)

-   {

-      png_write_tIME(png_ptr, &(info_ptr->mod_time));

-      png_ptr->mode |= PNG_WROTE_tIME;

-   }

-#endif /* tIME */

-

-#ifdef PNG_WRITE_sPLT_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_sPLT)

-     for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)

-       png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);

-#endif /* sPLT */

-

-#ifdef PNG_WRITE_TEXT_SUPPORTED

-   /* Check to see if we need to write text chunks */

-   for (i = 0; i < info_ptr->num_text; i++)

-   {

-      png_debug2(2, "Writing header text chunk %d, type %d", i,

-         info_ptr->text[i].compression);

-      /* An internationalized chunk? */

-      if (info_ptr->text[i].compression > 0)

-      {

-#ifdef PNG_WRITE_iTXt_SUPPORTED

-          /* Write international chunk */

-          png_write_iTXt(png_ptr,

-                         info_ptr->text[i].compression,

-                         info_ptr->text[i].key,

-                         info_ptr->text[i].lang,

-                         info_ptr->text[i].lang_key,

-                         info_ptr->text[i].text);

-#else

-          png_warning(png_ptr, "Unable to write international text");

-#endif

-          /* Mark this chunk as written */

-          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

-      }

-      /* If we want a compressed text chunk */

-      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)

-      {

-#ifdef PNG_WRITE_zTXt_SUPPORTED

-         /* Write compressed chunk */

-         png_write_zTXt(png_ptr, info_ptr->text[i].key,

-            info_ptr->text[i].text, 0,

-            info_ptr->text[i].compression);

-#else

-         png_warning(png_ptr, "Unable to write compressed text");

-#endif

-         /* Mark this chunk as written */

-         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

-      }

-      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

-      {

-#ifdef PNG_WRITE_tEXt_SUPPORTED

-         /* Write uncompressed chunk */

-         png_write_tEXt(png_ptr, info_ptr->text[i].key,

-                         info_ptr->text[i].text,

-                         0);

-         /* Mark this chunk as written */

-         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 /* tEXt */

-

-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   if (info_ptr->unknown_chunks_num)

-   {

-      png_unknown_chunk *up;

-

-      png_debug(5, "writing extra chunks");

-

-      for (up = info_ptr->unknown_chunks;

-           up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;

-           up++)

-      {

-         int keep = png_handle_as_unknown(png_ptr, up->name);

-         if (keep != PNG_HANDLE_CHUNK_NEVER &&

-            up->location && (up->location & PNG_HAVE_PLTE) &&

-            !(up->location & PNG_HAVE_IDAT) &&

-            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

-            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

-         {

-            png_write_chunk(png_ptr, up->name, up->data, up->size);

-         }

-      }

-   }

-#endif

-}

-

-/* Writes the end of the PNG file.  If you don't want to write comments or

- * time information, you can pass NULL for info.  If you already wrote these

- * in png_write_info(), do not write them again here.  If you have long

- * comments, I suggest writing them here, and compressing them.

- */

-void PNGAPI

-png_write_end(png_structp png_ptr, png_infop info_ptr)

-{

-   png_debug(1, "in png_write_end");

-

-   if (png_ptr == NULL)

-      return;

-   if (!(png_ptr->mode & PNG_HAVE_IDAT))

-      png_error(png_ptr, "No IDATs written into file");

-

-   /* See if user wants us to write information chunks */

-   if (info_ptr != NULL)

-   {

-#ifdef PNG_WRITE_TEXT_SUPPORTED

-      int i; /* local index variable */

-#endif

-#ifdef PNG_WRITE_tIME_SUPPORTED

-      /* Check to see if user has supplied a time chunk */

-      if ((info_ptr->valid & PNG_INFO_tIME) &&

-         !(png_ptr->mode & PNG_WROTE_tIME))

-         png_write_tIME(png_ptr, &(info_ptr->mod_time));

-#endif

-#ifdef PNG_WRITE_TEXT_SUPPORTED

-      /* Loop through comment chunks */

-      for (i = 0; i < info_ptr->num_text; i++)

-      {

-         png_debug2(2, "Writing trailer text chunk %d, type %d", i,

-            info_ptr->text[i].compression);

-         /* An internationalized chunk? */

-         if (info_ptr->text[i].compression > 0)

-         {

-#ifdef PNG_WRITE_iTXt_SUPPORTED

-            /* Write international chunk */

-            png_write_iTXt(png_ptr,

-                        info_ptr->text[i].compression,

-                        info_ptr->text[i].key,

-                        info_ptr->text[i].lang,

-                        info_ptr->text[i].lang_key,

-                        info_ptr->text[i].text);

-#else

-            png_warning(png_ptr, "Unable to write international text");

-#endif

-            /* Mark this chunk as written */

-            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

-         }

-         else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)

-         {

-#ifdef PNG_WRITE_zTXt_SUPPORTED

-            /* Write compressed chunk */

-            png_write_zTXt(png_ptr, info_ptr->text[i].key,

-               info_ptr->text[i].text, 0,

-               info_ptr->text[i].compression);

-#else

-            png_warning(png_ptr, "Unable to write compressed text");

-#endif

-            /* Mark this chunk as written */

-            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

-         }

-         else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

-         {

-#ifdef PNG_WRITE_tEXt_SUPPORTED

-            /* Write uncompressed chunk */

-            png_write_tEXt(png_ptr, info_ptr->text[i].key,

-               info_ptr->text[i].text, 0);

-#else

-            png_warning(png_ptr, "Unable to write uncompressed text");

-#endif

-

-            /* Mark this chunk as written */

-            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

-         }

-      }

-#endif

-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   if (info_ptr->unknown_chunks_num)

-   {

-      png_unknown_chunk *up;

-

-      png_debug(5, "writing extra chunks");

-

-      for (up = info_ptr->unknown_chunks;

-           up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;

-           up++)

-      {

-         int keep = png_handle_as_unknown(png_ptr, up->name);

-         if (keep != PNG_HANDLE_CHUNK_NEVER &&

-            up->location && (up->location & PNG_AFTER_IDAT) &&

-            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

-            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

-         {

-            png_write_chunk(png_ptr, up->name, up->data, up->size);

-         }

-      }

-   }

-#endif

-   }

-

-   png_ptr->mode |= PNG_AFTER_IDAT;

-

-   /* Write end of PNG file */

-   png_write_IEND(png_ptr);

-   /* 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

-    * do not set png_ptr->output_flush_fn to crash.  If your application

-    * experiences a problem, please try building libpng with

-    * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to

-    * png-mng-implement at lists.sf.net .  This kludge will be removed

-    * from libpng-1.4.0.

-    */

-#if defined(PNG_WRITE_FLUSH_SUPPORTED) && \

-    defined(PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED)

-   png_flush(png_ptr);

-#endif

-}

-

-#ifdef PNG_CONVERT_tIME_SUPPORTED

-/* "tm" structure is not supported on WindowsCE */

-void PNGAPI

-png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)

-{

-   png_debug(1, "in png_convert_from_struct_tm");

-

-   ptime->year = (png_uint_16)(1900 + ttime->tm_year);

-   ptime->month = (png_byte)(ttime->tm_mon + 1);

-   ptime->day = (png_byte)ttime->tm_mday;

-   ptime->hour = (png_byte)ttime->tm_hour;

-   ptime->minute = (png_byte)ttime->tm_min;

-   ptime->second = (png_byte)ttime->tm_sec;

-}

-

-void PNGAPI

-png_convert_from_time_t(png_timep ptime, time_t ttime)

-{

-   struct tm *tbuf;

-

-   png_debug(1, "in png_convert_from_time_t");

-

-   tbuf = gmtime(&ttime);

-   png_convert_from_struct_tm(ptime, tbuf);

-}

-#endif

-

-/* Initialize png_ptr structure, and allocate any memory needed */

-png_structp PNGAPI

-png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)

-{

-#ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,

-      warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));

-}

-

-/* Alternate initialize png_ptr structure, and allocate any memory needed */

-png_structp PNGAPI

-png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)

-{

-#endif /* PNG_USER_MEM_SUPPORTED */

-#ifdef PNG_SETJMP_SUPPORTED

-   volatile

-#endif

-   png_structp png_ptr;

-#ifdef PNG_SETJMP_SUPPORTED

-#ifdef USE_FAR_KEYWORD

-   jmp_buf jmpbuf;

-#endif

-#endif

-   int i;

-

-   png_debug(1, "in png_create_write_struct");

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

-      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);

-#else

-   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

-#endif /* PNG_USER_MEM_SUPPORTED */

-   if (png_ptr == NULL)

-      return (NULL);

-

-   /* Added at libpng-1.2.6 */

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

-   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-#ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

-#else

-   if (setjmp(png_ptr->jmpbuf))

-#endif

-   {

-      png_free(png_ptr, png_ptr->zbuf);

-      png_ptr->zbuf = NULL;

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)png_ptr,

-         (png_free_ptr)free_fn, (png_voidp)mem_ptr);

-#else

-      png_destroy_struct((png_voidp)png_ptr);

-#endif

-      return (NULL);

-   }

-#ifdef USE_FAR_KEYWORD

-   png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));

-#endif

-#endif

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

-#endif /* PNG_USER_MEM_SUPPORTED */

-   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

-

-   if (user_png_ver)

-   {

-      i = 0;

-      do

-      {

-         if (user_png_ver[i] != png_libpng_ver[i])

-            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

-      } while (png_libpng_ver[i++]);

-   }

-

-   if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)

-   {

-     /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so

-      * we must recompile any applications that use any older library version.

-      * For versions after libpng 1.0, we will be compatible, so we need

-      * only check the first digit.

-      */

-     if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||

-         (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||

-         (user_png_ver[0] == '0' && user_png_ver[2] < '9'))

-     {

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-        char msg[80];

-        if (user_png_ver)

-        {

-           png_snprintf(msg, 80,

-              "Application was compiled with png.h from libpng-%.20s",

-              user_png_ver);

-           png_warning(png_ptr, msg);

-        }

-        png_snprintf(msg, 80,

-           "Application  is  running with png.c from libpng-%.20s",

-           png_libpng_ver);

-        png_warning(png_ptr, msg);

-#endif

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-        png_ptr->flags = 0;

-#endif

-        png_error(png_ptr,

-           "Incompatible libpng version in application and library");

-     }

-   }

-

-   /* Initialize zbuf - compression buffer */

-   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

-   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

-     (png_uint_32)png_ptr->zbuf_size);

-

-   png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,

-      png_flush_ptr_NULL);

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,

-      1, png_doublep_NULL, png_doublep_NULL);

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-   /* Applications that neglect to set up their own setjmp() and then

-    * encounter a png_error() will longjmp here.  Since the jmpbuf is

-    * then meaningless we abort instead of returning.

-    */

-#ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

-      PNG_ABORT();

-   png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));

-#else

-   if (setjmp(png_ptr->jmpbuf))

-      PNG_ABORT();

-#endif

-#endif

-   return (png_ptr);

-}

-

-/* Initialize png_ptr structure, and allocate any memory needed */

-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

-/* Deprecated. */

-#undef png_write_init

-void PNGAPI

-png_write_init(png_structp png_ptr)

-{

-   /* We only come here via pre-1.0.7-compiled applications */

-   png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0);

-}

-

-void PNGAPI

-png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,

-   png_size_t png_struct_size, png_size_t png_info_size)

-{

-   /* We only come here via pre-1.0.12-compiled applications */

-   if (png_ptr == NULL) return;

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-   if (png_sizeof(png_struct) > png_struct_size ||

-      png_sizeof(png_info) > png_info_size)

-   {

-      char msg[80];

-      png_ptr->warning_fn = NULL;

-      if (user_png_ver)

-      {

-         png_snprintf(msg, 80,

-            "Application was compiled with png.h from libpng-%.20s",

-            user_png_ver);

-         png_warning(png_ptr, msg);

-      }

-      png_snprintf(msg, 80,

-         "Application  is  running with png.c from libpng-%.20s",

-         png_libpng_ver);

-      png_warning(png_ptr, msg);

-   }

-#endif

-   if (png_sizeof(png_struct) > png_struct_size)

-   {

-      png_ptr->error_fn = NULL;

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-      png_ptr->flags = 0;

-#endif

-      png_error(png_ptr,

-      "The png struct allocated by the application for writing is too small.");

-   }

-   if (png_sizeof(png_info) > png_info_size)

-   {

-      png_ptr->error_fn = NULL;

-#ifdef PNG_ERROR_NUMBERS_SUPPORTED

-      png_ptr->flags = 0;

-#endif

-      png_error(png_ptr,

-      "The info struct allocated by the application for writing is too small.");

-   }

-   png_write_init_3(&png_ptr, user_png_ver, png_struct_size);

-}

-#endif /* PNG_1_0_X || PNG_1_2_X */

-

-

-void PNGAPI

-png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,

-   png_size_t png_struct_size)

-{

-   png_structp png_ptr = *ptr_ptr;

-#ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf tmp_jmp; /* to save current jump buffer */

-#endif

-

-   int i = 0;

-

-   if (png_ptr == NULL)

-      return;

-

-   do

-   {

-      if (user_png_ver[i] != png_libpng_ver[i])

-      {

-#ifdef PNG_LEGACY_SUPPORTED

-         png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

-#else

-         png_ptr->warning_fn = NULL;

-         png_warning(png_ptr,

- "Application uses deprecated png_write_init() and should be recompiled.");

-#endif

-      }

-   } while (png_libpng_ver[i++]);

-

-   png_debug(1, "in png_write_init_3");

-

-#ifdef PNG_SETJMP_SUPPORTED

-   /* Save jump buffer and error functions */

-   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

-#endif

-

-   if (png_sizeof(png_struct) > png_struct_size)

-   {

-      png_destroy_struct(png_ptr);

-      png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

-      *ptr_ptr = png_ptr;

-   }

-

-   /* Reset all variables to 0 */

-   png_memset(png_ptr, 0, png_sizeof(png_struct));

-

-   /* Added at libpng-1.2.6 */

-#ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

-   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-   /* Restore jump buffer */

-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

-#endif

-

-   png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,

-      png_flush_ptr_NULL);

-

-   /* Initialize zbuf - compression buffer */

-   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

-   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

-     (png_uint_32)png_ptr->zbuf_size);

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,

-      1, png_doublep_NULL, png_doublep_NULL);

-#endif

-}

-

-/* Write a few rows of image data.  If the image is interlaced,

- * either you will have to write the 7 sub images, or, if you

- * have called png_set_interlace_handling(), you will have to

- * "write" the image seven times.

- */

-void PNGAPI

-png_write_rows(png_structp png_ptr, png_bytepp row,

-   png_uint_32 num_rows)

-{

-   png_uint_32 i; /* row counter */

-   png_bytepp rp; /* row pointer */

-

-   png_debug(1, "in png_write_rows");

-

-   if (png_ptr == NULL)

-      return;

-

-   /* Loop through the rows */

-   for (i = 0, rp = row; i < num_rows; i++, rp++)

-   {

-      png_write_row(png_ptr, *rp);

-   }

-}

-

-/* Write the image.  You only need to call this function once, even

- * if you are writing an interlaced image.

- */

-void PNGAPI

-png_write_image(png_structp png_ptr, png_bytepp image)

-{

-   png_uint_32 i; /* row index */

-   int pass, num_pass; /* pass variables */

-   png_bytepp rp; /* points to current row */

-

-   if (png_ptr == NULL)

-      return;

-

-   png_debug(1, "in png_write_image");

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* Initialize interlace handling.  If image is not interlaced,

-    * this will set pass to 1

-    */

-   num_pass = png_set_interlace_handling(png_ptr);

-#else

-   num_pass = 1;

-#endif

-   /* Loop through passes */

-   for (pass = 0; pass < num_pass; pass++)

-   {

-      /* Loop through image */

-      for (i = 0, rp = image; i < png_ptr->height; i++, rp++)

-      {

-         png_write_row(png_ptr, *rp);

-      }

-   }

-}

-

-/* Called by user to write a row of image data */

-void PNGAPI

-png_write_row(png_structp png_ptr, png_bytep row)

-{

-   if (png_ptr == NULL)

-      return;

-

-   png_debug2(1, "in png_write_row (row %ld, pass %d)",

-      png_ptr->row_number, png_ptr->pass);

-

-   /* Initialize transformations and other stuff if first time */

-   if (png_ptr->row_number == 0 && png_ptr->pass == 0)

-   {

-      /* Make sure we wrote the header info */

-      if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))

-         png_error(png_ptr,

-            "png_write_info was never called before png_write_row.");

-

-      /* Check for transforms that have been set but were defined out */

-#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)

-      if (png_ptr->transformations & PNG_INVERT_MONO)

-         png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");

-#endif

-#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)

-      if (png_ptr->transformations & PNG_FILLER)

-         png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");

-#endif

-#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)

-      if (png_ptr->transformations & PNG_PACKSWAP)

-         png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");

-#endif

-#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)

-      if (png_ptr->transformations & PNG_PACK)

-         png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");

-#endif

-#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)

-      if (png_ptr->transformations & PNG_SHIFT)

-         png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");

-#endif

-#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)

-      if (png_ptr->transformations & PNG_BGR)

-         png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");

-#endif

-#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)

-      if (png_ptr->transformations & PNG_SWAP_BYTES)

-         png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");

-#endif

-

-      png_write_start_row(png_ptr);

-   }

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* If interlaced and not interested in row, return */

-   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

-   {

-      switch (png_ptr->pass)

-      {

-         case 0:

-            if (png_ptr->row_number & 0x07)

-            {

-               png_write_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 1:

-            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

-            {

-               png_write_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 2:

-            if ((png_ptr->row_number & 0x07) != 4)

-            {

-               png_write_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 3:

-            if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)

-            {

-               png_write_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 4:

-            if ((png_ptr->row_number & 0x03) != 2)

-            {

-               png_write_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 5:

-            if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)

-            {

-               png_write_finish_row(png_ptr);

-               return;

-            }

-            break;

-         case 6:

-            if (!(png_ptr->row_number & 0x01))

-            {

-               png_write_finish_row(png_ptr);

-               return;

-            }

-            break;

-      }

-   }

-#endif

-

-   /* Set up row info for transformations */

-   png_ptr->row_info.color_type = png_ptr->color_type;

-   png_ptr->row_info.width = png_ptr->usr_width;

-   png_ptr->row_info.channels = png_ptr->usr_channels;

-   png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;

-   png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

-      png_ptr->row_info.channels);

-

-   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-      png_ptr->row_info.width);

-

-   png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type);

-   png_debug1(3, "row_info->width = %lu", png_ptr->row_info.width);

-   png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels);

-   png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth);

-   png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth);

-   png_debug1(3, "row_info->rowbytes = %lu", png_ptr->row_info.rowbytes);

-

-   /* Copy user's row into buffer, leaving room for filter byte. */

-   png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,

-      png_ptr->row_info.rowbytes);

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* Handle interlacing */

-   if (png_ptr->interlaced && png_ptr->pass < 6 &&

-      (png_ptr->transformations & PNG_INTERLACE))

-   {

-      png_do_write_interlace(&(png_ptr->row_info),

-         png_ptr->row_buf + 1, png_ptr->pass);

-      /* This should always get caught above, but still ... */

-      if (!(png_ptr->row_info.width))

-      {

-         png_write_finish_row(png_ptr);

-         return;

-      }

-   }

-#endif

-

-   /* Handle other transformations */

-   if (png_ptr->transformations)

-      png_do_write_transformations(png_ptr);

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   /* Write filter_method 64 (intrapixel differencing) only if

-    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

-    * 2. Libpng did not write a PNG signature (this filter_method is only

-    *    used in PNG datastreams that are embedded in MNG datastreams) and

-    * 3. The application called png_permit_mng_features with a mask that

-    *    included PNG_FLAG_MNG_FILTER_64 and

-    * 4. The filter_method is 64 and

-    * 5. The color_type is RGB or RGBA

-    */

-   if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

-      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

-   {

-      /* Intrapixel differencing */

-      png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

-   }

-#endif

-

-   /* Find a filter if necessary, filter the row and write it out. */

-   png_write_find_filter(png_ptr, &(png_ptr->row_info));

-

-   if (png_ptr->write_row_fn != NULL)

-      (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

-}

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-/* Set the automatic flush interval or 0 to turn flushing off */

-void PNGAPI

-png_set_flush(png_structp png_ptr, int nrows)

-{

-   png_debug(1, "in png_set_flush");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);

-}

-

-/* Flush the current output buffers now */

-void PNGAPI

-png_write_flush(png_structp png_ptr)

-{

-   int wrote_IDAT;

-

-   png_debug(1, "in png_write_flush");

-

-   if (png_ptr == NULL)

-      return;

-   /* We have already written out all of the data */

-   if (png_ptr->row_number >= png_ptr->num_rows)

-      return;

-

-   do

-   {

-      int ret;

-

-      /* Compress the data */

-      ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);

-      wrote_IDAT = 0;

-

-      /* Check for compression errors */

-      if (ret != Z_OK)

-      {

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-

-      if (!(png_ptr->zstream.avail_out))

-      {

-         /* Write the IDAT and reset the zlib output buffer */

-         png_write_IDAT(png_ptr, png_ptr->zbuf,

-                        png_ptr->zbuf_size);

-         png_ptr->zstream.next_out = png_ptr->zbuf;

-         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-         wrote_IDAT = 1;

-      }

-   } while(wrote_IDAT == 1);

-

-   /* If there is any data left to be output, write it into a new IDAT */

-   if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)

-   {

-      /* Write the IDAT and reset the zlib output buffer */

-      png_write_IDAT(png_ptr, png_ptr->zbuf,

-                     png_ptr->zbuf_size - png_ptr->zstream.avail_out);

-      png_ptr->zstream.next_out = png_ptr->zbuf;

-      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-   }

-   png_ptr->flush_rows = 0;

-   png_flush(png_ptr);

-}

-#endif /* PNG_WRITE_FLUSH_SUPPORTED */

-

-/* Free all memory used by the write */

-void PNGAPI

-png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)

-{

-   png_structp png_ptr = NULL;

-   png_infop info_ptr = NULL;

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn = NULL;

-   png_voidp mem_ptr = NULL;

-#endif

-

-   png_debug(1, "in png_destroy_write_struct");

-

-   if (png_ptr_ptr != NULL)

-   {

-      png_ptr = *png_ptr_ptr;

-#ifdef PNG_USER_MEM_SUPPORTED

-      free_fn = png_ptr->free_fn;

-      mem_ptr = png_ptr->mem_ptr;

-#endif

-   }

-

-#ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr != NULL)

-   {

-      free_fn = png_ptr->free_fn;

-      mem_ptr = png_ptr->mem_ptr;

-   }

-#endif

-

-   if (info_ptr_ptr != NULL)

-      info_ptr = *info_ptr_ptr;

-

-   if (info_ptr != NULL)

-   {

-      if (png_ptr != NULL)

-      {

-        png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

-

-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-        if (png_ptr->num_chunk_list)

-        {

-           png_free(png_ptr, png_ptr->chunk_list);

-           png_ptr->chunk_list = NULL;

-           png_ptr->num_chunk_list = 0;

-        }

-#endif

-      }

-

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

-         (png_voidp)mem_ptr);

-#else

-      png_destroy_struct((png_voidp)info_ptr);

-#endif

-      *info_ptr_ptr = NULL;

-   }

-

-   if (png_ptr != NULL)

-   {

-      png_write_destroy(png_ptr);

-#ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,

-         (png_voidp)mem_ptr);

-#else

-      png_destroy_struct((png_voidp)png_ptr);

-#endif

-      *png_ptr_ptr = NULL;

-   }

-}

-

-

-/* Free any memory used in png_ptr struct (old method) */

-void /* PRIVATE */

-png_write_destroy(png_structp png_ptr)

-{

-#ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf tmp_jmp; /* Save jump buffer */

-#endif

-   png_error_ptr error_fn;

-   png_error_ptr warning_fn;

-   png_voidp error_ptr;

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn;

-#endif

-

-   png_debug(1, "in png_write_destroy");

-

-   /* Free any memory zlib uses */

-   deflateEnd(&png_ptr->zstream);

-

-   /* Free our memory.  png_free checks NULL for us. */

-   png_free(png_ptr, png_ptr->zbuf);

-   png_free(png_ptr, png_ptr->row_buf);

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-   png_free(png_ptr, png_ptr->prev_row);

-   png_free(png_ptr, png_ptr->sub_row);

-   png_free(png_ptr, png_ptr->up_row);

-   png_free(png_ptr, png_ptr->avg_row);

-   png_free(png_ptr, png_ptr->paeth_row);

-#endif

-

-#ifdef PNG_TIME_RFC1123_SUPPORTED

-   png_free(png_ptr, png_ptr->time_buffer);

-#endif

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   png_free(png_ptr, png_ptr->prev_filters);

-   png_free(png_ptr, png_ptr->filter_weights);

-   png_free(png_ptr, png_ptr->inv_filter_weights);

-   png_free(png_ptr, png_ptr->filter_costs);

-   png_free(png_ptr, png_ptr->inv_filter_costs);

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-   /* Reset structure */

-   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

-#endif

-

-   error_fn = png_ptr->error_fn;

-   warning_fn = png_ptr->warning_fn;

-   error_ptr = png_ptr->error_ptr;

-#ifdef PNG_USER_MEM_SUPPORTED

-   free_fn = png_ptr->free_fn;

-#endif

-

-   png_memset(png_ptr, 0, png_sizeof(png_struct));

-

-   png_ptr->error_fn = error_fn;

-   png_ptr->warning_fn = warning_fn;

-   png_ptr->error_ptr = error_ptr;

-#ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr->free_fn = free_fn;

-#endif

-

-#ifdef PNG_SETJMP_SUPPORTED

-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

-#endif

-}

-

-/* Allow the application to select one or more row filters to use. */

-void PNGAPI

-png_set_filter(png_structp png_ptr, int method, int filters)

-{

-   png_debug(1, "in png_set_filter");

-

-   if (png_ptr == NULL)

-      return;

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

-      (method == PNG_INTRAPIXEL_DIFFERENCING))

-         method = PNG_FILTER_TYPE_BASE;

-#endif

-   if (method == PNG_FILTER_TYPE_BASE)

-   {

-      switch (filters & (PNG_ALL_FILTERS | 0x07))

-      {

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-         case 5:

-         case 6:

-         case 7: png_warning(png_ptr, "Unknown row filter for method 0");

-#endif /* PNG_WRITE_FILTER_SUPPORTED */

-         case PNG_FILTER_VALUE_NONE:

-              png_ptr->do_filter = PNG_FILTER_NONE; break;

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-         case PNG_FILTER_VALUE_SUB:

-              png_ptr->do_filter = PNG_FILTER_SUB; break;

-         case PNG_FILTER_VALUE_UP:

-              png_ptr->do_filter = PNG_FILTER_UP; break;

-         case PNG_FILTER_VALUE_AVG:

-              png_ptr->do_filter = PNG_FILTER_AVG; break;

-         case PNG_FILTER_VALUE_PAETH:

-              png_ptr->do_filter = PNG_FILTER_PAETH; break;

-         default: png_ptr->do_filter = (png_byte)filters; break;

-#else

-         default: png_warning(png_ptr, "Unknown row filter for method 0");

-#endif /* PNG_WRITE_FILTER_SUPPORTED */

-      }

-

-      /* If we have allocated the row_buf, this means we have already started

-       * with the image and we should have allocated all of the filter buffers

-       * that have been selected.  If prev_row isn't already allocated, then

-       * it is too late to start using the filters that need it, since we

-       * will be missing the data in the previous row.  If an application

-       * wants to start and stop using particular filters during compression,

-       * it should start out with all of the filters, and then add and

-       * remove them after the start of compression.

-       */

-      if (png_ptr->row_buf != NULL)

-      {

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-         if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)

-         {

-            png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

-              (png_ptr->rowbytes + 1));

-            png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

-         }

-

-         if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)

-         {

-            if (png_ptr->prev_row == NULL)

-            {

-               png_warning(png_ptr, "Can't add Up filter after starting");

-               png_ptr->do_filter &= ~PNG_FILTER_UP;

-            }

-            else

-            {

-               png_ptr->up_row = (png_bytep)png_malloc(png_ptr,

-                  (png_ptr->rowbytes + 1));

-               png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

-            }

-         }

-

-         if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)

-         {

-            if (png_ptr->prev_row == NULL)

-            {

-               png_warning(png_ptr, "Can't add Average filter after starting");

-               png_ptr->do_filter &= ~PNG_FILTER_AVG;

-            }

-            else

-            {

-               png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

-                  (png_ptr->rowbytes + 1));

-               png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

-            }

-         }

-

-         if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&

-             png_ptr->paeth_row == NULL)

-         {

-            if (png_ptr->prev_row == NULL)

-            {

-               png_warning(png_ptr, "Can't add Paeth filter after starting");

-               png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);

-            }

-            else

-            {

-               png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,

-                  (png_ptr->rowbytes + 1));

-               png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

-            }

-         }

-

-         if (png_ptr->do_filter == PNG_NO_FILTERS)

-#endif /* PNG_WRITE_FILTER_SUPPORTED */

-            png_ptr->do_filter = PNG_FILTER_NONE;

-      }

-   }

-   else

-      png_error(png_ptr, "Unknown custom filter method");

-}

-

-/* This allows us to influence the way in which libpng chooses the "best"

- * filter for the current scanline.  While the "minimum-sum-of-absolute-

- * differences metric is relatively fast and effective, there is some

- * question as to whether it can be improved upon by trying to keep the

- * filtered data going to zlib more consistent, hopefully resulting in

- * better compression.

- */

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED      /* GRR 970116 */

-void PNGAPI

-png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,

-   int num_weights, png_doublep filter_weights,

-   png_doublep filter_costs)

-{

-   int i;

-

-   png_debug(1, "in png_set_filter_heuristics");

-

-   if (png_ptr == NULL)

-      return;

-   if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)

-   {

-      png_warning(png_ptr, "Unknown filter heuristic method");

-      return;

-   }

-

-   if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)

-   {

-      heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;

-   }

-

-   if (num_weights < 0 || filter_weights == NULL ||

-      heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)

-   {

-      num_weights = 0;

-   }

-

-   png_ptr->num_prev_filters = (png_byte)num_weights;

-   png_ptr->heuristic_method = (png_byte)heuristic_method;

-

-   if (num_weights > 0)

-   {

-      if (png_ptr->prev_filters == NULL)

-      {

-         png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(png_sizeof(png_byte) * num_weights));

-

-         /* To make sure that the weighting starts out fairly */

-         for (i = 0; i < num_weights; i++)

-         {

-            png_ptr->prev_filters[i] = 255;

-         }

-      }

-

-      if (png_ptr->filter_weights == NULL)

-      {

-         png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,

-            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

-

-         png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,

-            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

-         for (i = 0; i < num_weights; i++)

-         {

-            png_ptr->inv_filter_weights[i] =

-            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

-         }

-      }

-

-      for (i = 0; i < num_weights; i++)

-      {

-         if (filter_weights[i] < 0.0)

-         {

-            png_ptr->inv_filter_weights[i] =

-            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

-         }

-         else

-         {

-            png_ptr->inv_filter_weights[i] =

-               (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);

-            png_ptr->filter_weights[i] =

-               (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);

-         }

-      }

-   }

-

-   /* If, in the future, there are other filter methods, this would

-    * need to be based on png_ptr->filter.

-    */

-   if (png_ptr->filter_costs == NULL)

-   {

-      png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,

-         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

-

-      png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,

-         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

-

-      for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)

-      {

-         png_ptr->inv_filter_costs[i] =

-         png_ptr->filter_costs[i] = PNG_COST_FACTOR;

-      }

-   }

-

-   /* Here is where we set the relative costs of the different filters.  We

-    * should take the desired compression level into account when setting

-    * the costs, so that Paeth, for instance, has a high relative cost at low

-    * compression levels, while it has a lower relative cost at higher

-    * compression settings.  The filter types are in order of increasing

-    * relative cost, so it would be possible to do this with an algorithm.

-    */

-   for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)

-   {

-      if (filter_costs == NULL || filter_costs[i] < 0.0)

-      {

-         png_ptr->inv_filter_costs[i] =

-         png_ptr->filter_costs[i] = PNG_COST_FACTOR;

-      }

-      else if (filter_costs[i] >= 1.0)

-      {

-         png_ptr->inv_filter_costs[i] =

-            (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);

-         png_ptr->filter_costs[i] =

-            (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);

-      }

-   }

-}

-#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */

-

-void PNGAPI

-png_set_compression_level(png_structp png_ptr, int level)

-{

-   png_debug(1, "in png_set_compression_level");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;

-   png_ptr->zlib_level = level;

-}

-

-void PNGAPI

-png_set_compression_mem_level(png_structp png_ptr, int mem_level)

-{

-   png_debug(1, "in png_set_compression_mem_level");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;

-   png_ptr->zlib_mem_level = mem_level;

-}

-

-void PNGAPI

-png_set_compression_strategy(png_structp png_ptr, int strategy)

-{

-   png_debug(1, "in png_set_compression_strategy");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;

-   png_ptr->zlib_strategy = strategy;

-}

-

-void PNGAPI

-png_set_compression_window_bits(png_structp png_ptr, int window_bits)

-{

-   if (png_ptr == NULL)

-      return;

-   if (window_bits > 15)

-      png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");

-   else if (window_bits < 8)

-      png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");

-#ifndef WBITS_8_OK

-   /* Avoid libpng bug with 256-byte windows */

-   if (window_bits == 8)

-     {

-       png_warning(png_ptr, "Compression window is being reset to 512");

-       window_bits = 9;

-     }

-#endif

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;

-   png_ptr->zlib_window_bits = window_bits;

-}

-

-void PNGAPI

-png_set_compression_method(png_structp png_ptr, int method)

-{

-   png_debug(1, "in png_set_compression_method");

-

-   if (png_ptr == NULL)

-      return;

-   if (method != 8)

-      png_warning(png_ptr, "Only compression method 8 is supported by PNG");

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;

-   png_ptr->zlib_method = method;

-}

-

-void PNGAPI

-png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)

-{

-   if (png_ptr == NULL)

-      return;

-   png_ptr->write_row_fn = write_row_fn;

-}

-

-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-void PNGAPI

-png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr

-   write_user_transform_fn)

-{

-   png_debug(1, "in png_set_write_user_transform_fn");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_USER_TRANSFORM;

-   png_ptr->write_user_transform_fn = write_user_transform_fn;

-}

-#endif

-

-

-#ifdef PNG_INFO_IMAGE_SUPPORTED

-void PNGAPI

-png_write_png(png_structp png_ptr, png_infop info_ptr,

-              int transforms, voidp params)

-{

-   if (png_ptr == NULL || info_ptr == NULL)

-      return;

-

-   /* Write the file header information. */

-   png_write_info(png_ptr, info_ptr);

-

-   /* ------ these transformations don't touch the info structure ------- */

-

-#ifdef PNG_WRITE_INVERT_SUPPORTED

-   /* Invert monochrome pixels */

-   if (transforms & PNG_TRANSFORM_INVERT_MONO)

-      png_set_invert_mono(png_ptr);

-#endif

-

-#ifdef PNG_WRITE_SHIFT_SUPPORTED

-   /* Shift the pixels up to a legal bit depth and fill in

-    * as appropriate to correctly scale the image.

-    */

-   if ((transforms & PNG_TRANSFORM_SHIFT)

-               && (info_ptr->valid & PNG_INFO_sBIT))

-      png_set_shift(png_ptr, &info_ptr->sig_bit);

-#endif

-

-#ifdef PNG_WRITE_PACK_SUPPORTED

-   /* Pack pixels into bytes */

-   if (transforms & PNG_TRANSFORM_PACKING)

-       png_set_packing(png_ptr);

-#endif

-

-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

-   /* Swap location of alpha bytes from ARGB to RGBA */

-   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)

-      png_set_swap_alpha(png_ptr);

-#endif

-

-#ifdef PNG_WRITE_FILLER_SUPPORTED

-   /* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */

-   if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)

-      png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);

-   else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)

-      png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

-#endif

-

-#ifdef PNG_WRITE_BGR_SUPPORTED

-   /* Flip BGR pixels to RGB */

-   if (transforms & PNG_TRANSFORM_BGR)

-      png_set_bgr(png_ptr);

-#endif

-

-#ifdef PNG_WRITE_SWAP_SUPPORTED

-   /* Swap bytes of 16-bit files to most significant byte first */

-   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)

-      png_set_swap(png_ptr);

-#endif

-

-#ifdef PNG_WRITE_PACKSWAP_SUPPORTED

-   /* Swap bits of 1, 2, 4 bit packed pixel formats */

-   if (transforms & PNG_TRANSFORM_PACKSWAP)

-      png_set_packswap(png_ptr);

-#endif

-

-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-   /* Invert the alpha channel from opacity to transparency */

-   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

-      png_set_invert_alpha(png_ptr);

-#endif

-

-   /* ----------------------- end of transformations ------------------- */

-

-   /* Write the bits */

-   if (info_ptr->valid & PNG_INFO_IDAT)

-       png_write_image(png_ptr, info_ptr->row_pointers);

-

-   /* It is REQUIRED to call this to finish writing the rest of the file */

-   png_write_end(png_ptr, info_ptr);

-

-   transforms = transforms; /* Quiet compiler warnings */

-   params = params;

-}

-#endif

-#endif /* PNG_WRITE_SUPPORTED */

+
+/* pngwrite.c - general routines to write a PNG file
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* Get internal access to png.h */
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+#include "pngpriv.h"
+
+/* Writes all the PNG information.  This is the suggested way to use the
+ * library.  If you have a new chunk to add, make a function to write it,
+ * and put it in the correct location here.  If you want the chunk written
+ * after the image data, put it in png_write_end().  I strongly encourage
+ * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
+ * the chunk, as that will keep the code from breaking if you want to just
+ * write a plain PNG file.  If you have long comments, I suggest writing
+ * them in png_write_end(), and compressing them.
+ */
+void PNGAPI
+png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_write_info_before_PLTE");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+   if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
+   {
+   /* Write PNG signature */
+   png_write_sig(png_ptr);
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))
+   {
+      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
+      png_ptr->mng_features_permitted = 0;
+   }
+#endif
+   /* Write IHDR information. */
+   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->filter_type,
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+      info_ptr->interlace_type);
+#else
+      0);
+#endif
+   /* The rest of these check to see if the valid field has the appropriate
+    * flag set, and if it does, writes the chunk.
+    */
+#ifdef PNG_WRITE_gAMA_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_gAMA)
+   {
+#  ifdef PNG_FLOATING_POINT_SUPPORTED
+      png_write_gAMA(png_ptr, info_ptr->gamma);
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+      png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);
+#  endif
+#endif
+   }
+#endif
+#ifdef PNG_WRITE_sRGB_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_sRGB)
+      png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
+#endif
+#ifdef PNG_WRITE_iCCP_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_iCCP)
+      png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,
+                     info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);
+#endif
+#ifdef PNG_WRITE_sBIT_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_sBIT)
+      png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
+#endif
+#ifdef PNG_WRITE_cHRM_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_cHRM)
+   {
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+      png_write_cHRM(png_ptr,
+         info_ptr->x_white, info_ptr->y_white,
+         info_ptr->x_red, info_ptr->y_red,
+         info_ptr->x_green, info_ptr->y_green,
+         info_ptr->x_blue, info_ptr->y_blue);
+#else
+#  ifdef PNG_FIXED_POINT_SUPPORTED
+      png_write_cHRM_fixed(png_ptr,
+         info_ptr->int_x_white, info_ptr->int_y_white,
+         info_ptr->int_x_red, info_ptr->int_y_red,
+         info_ptr->int_x_green, info_ptr->int_y_green,
+         info_ptr->int_x_blue, info_ptr->int_y_blue);
+#  endif
+#endif
+   }
+#endif
+#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+   if (info_ptr->unknown_chunks_num)
+   {
+      png_unknown_chunk *up;
+
+      png_debug(5, "writing extra chunks");
+
+      for (up = info_ptr->unknown_chunks;
+           up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+           up++)
+      {
+         int keep = png_handle_as_unknown(png_ptr, up->name);
+         if (keep != PNG_HANDLE_CHUNK_NEVER &&
+            up->location && !(up->location & PNG_HAVE_PLTE) &&
+            !(up->location & PNG_HAVE_IDAT) &&
+            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+         {
+            if (up->size == 0)
+               png_warning(png_ptr, "Writing zero-length unknown chunk");
+            png_write_chunk(png_ptr, up->name, up->data, up->size);
+         }
+      }
+   }
+#endif
+      png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
+   }
+}
+
+void PNGAPI
+png_write_info(png_structp png_ptr, png_infop info_ptr)
+{
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+   int i;
+#endif
+
+   png_debug(1, "in png_write_info");
+
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   png_write_info_before_PLTE(png_ptr, info_ptr);
+
+   if (info_ptr->valid & PNG_INFO_PLTE)
+      png_write_PLTE(png_ptr, info_ptr->palette,
+         (png_uint_32)info_ptr->num_palette);
+   else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      png_error(png_ptr, "Valid palette required for paletted images");
+
+#ifdef PNG_WRITE_tRNS_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_tRNS)
+   {
+#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+      /* Invert the alpha channel (in tRNS) */
+      if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
+         info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         int j;
+         for (j = 0; j<(int)info_ptr->num_trans; j++)
+            info_ptr->trans_alpha[j] = (png_byte)(255 - info_ptr->trans_alpha[j]);
+      }
+#endif
+      png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
+         info_ptr->num_trans, info_ptr->color_type);
+   }
+#endif
+#ifdef PNG_WRITE_bKGD_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_bKGD)
+      png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
+#endif
+#ifdef PNG_WRITE_hIST_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_hIST)
+      png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
+#endif
+#ifdef PNG_WRITE_oFFs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_oFFs)
+      png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
+         info_ptr->offset_unit_type);
+#endif
+#ifdef PNG_WRITE_pCAL_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_pCAL)
+      png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
+         info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
+         info_ptr->pcal_units, info_ptr->pcal_params);
+#endif
+
+#ifdef PNG_sCAL_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_sCAL)
+#ifdef PNG_WRITE_sCAL_SUPPORTED
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
+      png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
+          info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);
+#else /* !FLOATING_POINT */
+#ifdef PNG_FIXED_POINT_SUPPORTED
+      png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
+          info_ptr->scal_s_width, info_ptr->scal_s_height);
+#endif /* FIXED_POINT */
+#endif /* FLOATING_POINT */
+#else  /* !WRITE_sCAL */
+      png_warning(png_ptr,
+          "png_write_sCAL not supported; sCAL chunk not written");
+#endif /* WRITE_sCAL */
+#endif /* sCAL */
+
+#ifdef PNG_WRITE_pHYs_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_pHYs)
+      png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
+         info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
+#endif /* pHYs */
+
+#ifdef PNG_WRITE_tIME_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_tIME)
+   {
+      png_write_tIME(png_ptr, &(info_ptr->mod_time));
+      png_ptr->mode |= PNG_WROTE_tIME;
+   }
+#endif /* tIME */
+
+#ifdef PNG_WRITE_sPLT_SUPPORTED
+   if (info_ptr->valid & PNG_INFO_sPLT)
+     for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
+       png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
+#endif /* sPLT */
+
+#ifdef PNG_WRITE_TEXT_SUPPORTED
+   /* Check to see if we need to write text chunks */
+   for (i = 0; i < info_ptr->num_text; i++)
+   {
+      png_debug2(2, "Writing header text chunk %d, type %d", i,
+         info_ptr->text[i].compression);
+      /* An internationalized chunk? */
+      if (info_ptr->text[i].compression > 0)
+      {
+#ifdef PNG_WRITE_iTXt_SUPPORTED
+          /* Write international chunk */
+          png_write_iTXt(png_ptr,
+                         info_ptr->text[i].compression,
+                         info_ptr->text[i].key,
+                         info_ptr->text[i].lang,
+                         info_ptr->text[i].lang_key,
+                         info_ptr->text[i].text);
+#else
+          png_warning(png_ptr, "Unable to write international text");
+#endif
+          /* Mark this chunk as written */
+          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+      }
+      /* If we want a compressed text chunk */
+      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
+      {
+#ifdef PNG_WRITE_zTXt_SUPPORTED
+         /* Write compressed chunk */
+         png_write_zTXt(png_ptr, info_ptr->text[i].key,
+            info_ptr->text[i].text, 0,
+            info_ptr->text[i].compression);
+#else
+         png_warning(png_ptr, "Unable to write compressed text");
+#endif
+         /* Mark this chunk as written */
+         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+      }
+      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
+      {
+#ifdef PNG_WRITE_tEXt_SUPPORTED
+         /* Write uncompressed chunk */
+         png_write_tEXt(png_ptr, info_ptr->text[i].key,
+                         info_ptr->text[i].text,
+                         0);
+         /* Mark this chunk as written */
+         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 /* tEXt */
+
+#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+   if (info_ptr->unknown_chunks_num)
+   {
+      png_unknown_chunk *up;
+
+      png_debug(5, "writing extra chunks");
+
+      for (up = info_ptr->unknown_chunks;
+           up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+           up++)
+      {
+         int keep = png_handle_as_unknown(png_ptr, up->name);
+         if (keep != PNG_HANDLE_CHUNK_NEVER &&
+            up->location && (up->location & PNG_HAVE_PLTE) &&
+            !(up->location & PNG_HAVE_IDAT) &&
+            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+         {
+            png_write_chunk(png_ptr, up->name, up->data, up->size);
+         }
+      }
+   }
+#endif
+}
+
+/* Writes the end of the PNG file.  If you don't want to write comments or
+ * time information, you can pass NULL for info.  If you already wrote these
+ * in png_write_info(), do not write them again here.  If you have long
+ * comments, I suggest writing them here, and compressing them.
+ */
+void PNGAPI
+png_write_end(png_structp png_ptr, png_infop info_ptr)
+{
+   png_debug(1, "in png_write_end");
+
+   if (png_ptr == NULL)
+      return;
+   if (!(png_ptr->mode & PNG_HAVE_IDAT))
+      png_error(png_ptr, "No IDATs written into file");
+
+   /* See if user wants us to write information chunks */
+   if (info_ptr != NULL)
+   {
+#ifdef PNG_WRITE_TEXT_SUPPORTED
+      int i; /* local index variable */
+#endif
+#ifdef PNG_WRITE_tIME_SUPPORTED
+      /* Check to see if user has supplied a time chunk */
+      if ((info_ptr->valid & PNG_INFO_tIME) &&
+         !(png_ptr->mode & PNG_WROTE_tIME))
+         png_write_tIME(png_ptr, &(info_ptr->mod_time));
+#endif
+#ifdef PNG_WRITE_TEXT_SUPPORTED
+      /* Loop through comment chunks */
+      for (i = 0; i < info_ptr->num_text; i++)
+      {
+         png_debug2(2, "Writing trailer text chunk %d, type %d", i,
+            info_ptr->text[i].compression);
+         /* An internationalized chunk? */
+         if (info_ptr->text[i].compression > 0)
+         {
+#ifdef PNG_WRITE_iTXt_SUPPORTED
+            /* Write international chunk */
+            png_write_iTXt(png_ptr,
+                        info_ptr->text[i].compression,
+                        info_ptr->text[i].key,
+                        info_ptr->text[i].lang,
+                        info_ptr->text[i].lang_key,
+                        info_ptr->text[i].text);
+#else
+            png_warning(png_ptr, "Unable to write international text");
+#endif
+            /* Mark this chunk as written */
+            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+         }
+         else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
+         {
+#ifdef PNG_WRITE_zTXt_SUPPORTED
+            /* Write compressed chunk */
+            png_write_zTXt(png_ptr, info_ptr->text[i].key,
+               info_ptr->text[i].text, 0,
+               info_ptr->text[i].compression);
+#else
+            png_warning(png_ptr, "Unable to write compressed text");
+#endif
+            /* Mark this chunk as written */
+            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+         }
+         else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
+         {
+#ifdef PNG_WRITE_tEXt_SUPPORTED
+            /* Write uncompressed chunk */
+            png_write_tEXt(png_ptr, info_ptr->text[i].key,
+               info_ptr->text[i].text, 0);
+#else
+            png_warning(png_ptr, "Unable to write uncompressed text");
+#endif
+
+            /* Mark this chunk as written */
+            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+         }
+      }
+#endif
+#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+   if (info_ptr->unknown_chunks_num)
+   {
+      png_unknown_chunk *up;
+
+      png_debug(5, "writing extra chunks");
+
+      for (up = info_ptr->unknown_chunks;
+           up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+           up++)
+      {
+         int keep = png_handle_as_unknown(png_ptr, up->name);
+         if (keep != PNG_HANDLE_CHUNK_NEVER &&
+            up->location && (up->location & PNG_AFTER_IDAT) &&
+            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+         {
+            png_write_chunk(png_ptr, up->name, up->data, up->size);
+         }
+      }
+   }
+#endif
+   }
+
+   png_ptr->mode |= PNG_AFTER_IDAT;
+
+   /* Write end of PNG file */
+   png_write_IEND(png_ptr);
+   /* 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
+    * do not set png_ptr->output_flush_fn to crash.  If your application
+    * experiences a problem, please try building libpng with
+    * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to
+    * png-mng-implement at lists.sf.net .
+    */
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+#  ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED
+   png_flush(png_ptr);
+#  endif
+#endif
+}
+
+#ifdef PNG_CONVERT_tIME_SUPPORTED
+/* "tm" structure is not supported on WindowsCE */
+void PNGAPI
+png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
+{
+   png_debug(1, "in png_convert_from_struct_tm");
+
+   ptime->year = (png_uint_16)(1900 + ttime->tm_year);
+   ptime->month = (png_byte)(ttime->tm_mon + 1);
+   ptime->day = (png_byte)ttime->tm_mday;
+   ptime->hour = (png_byte)ttime->tm_hour;
+   ptime->minute = (png_byte)ttime->tm_min;
+   ptime->second = (png_byte)ttime->tm_sec;
+}
+
+void PNGAPI
+png_convert_from_time_t(png_timep ptime, time_t ttime)
+{
+   struct tm *tbuf;
+
+   png_debug(1, "in png_convert_from_time_t");
+
+   tbuf = gmtime(&ttime);
+   png_convert_from_struct_tm(ptime, tbuf);
+}
+#endif
+
+/* Initialize png_ptr structure, and allocate any memory needed */
+png_structp PNGAPI
+png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn)
+{
+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
+      warn_fn, NULL, NULL, NULL));
+}
+
+/* Alternate initialize png_ptr structure, and allocate any memory needed */
+png_structp PNGAPI
+png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+   volatile int png_cleanup_needed = 0;
+#ifdef PNG_SETJMP_SUPPORTED
+   volatile
+#endif
+   png_structp png_ptr;
+#ifdef PNG_SETJMP_SUPPORTED
+#ifdef USE_FAR_KEYWORD
+   jmp_buf jmpbuf;
+#endif
+#endif
+   int i;
+
+   png_debug(1, "in png_create_write_struct");
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
+#else
+   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+#endif /* PNG_USER_MEM_SUPPORTED */
+   if (png_ptr == NULL)
+      return (NULL);
+
+   /* Added at libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
+   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* Applications that neglect to set up their own setjmp() and then
+   encounter a png_error() will longjmp here.  Since the jmpbuf is
+   then meaningless we abort instead of returning. */
+#ifdef USE_FAR_KEYWORD
+   if (setjmp(jmpbuf))
+#else
+   if (setjmp(png_jmpbuf(png_ptr))) /* sets longjmp to match setjmp */
+#endif
+#ifdef USE_FAR_KEYWORD
+   png_memcpy(png_jmpbuf(png_ptr), jmpbuf, png_sizeof(jmp_buf));
+#endif
+      PNG_ABORT();
+#endif
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+#endif /* PNG_USER_MEM_SUPPORTED */
+   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
+
+   if (user_png_ver)
+   {
+      i = 0;
+      do
+      {
+         if (user_png_ver[i] != png_libpng_ver[i])
+            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+      } while (png_libpng_ver[i++]);
+   }
+
+   if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
+   {
+     /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
+      * we must recompile any applications that use any older library version.
+      * For versions after libpng 1.0, we will be compatible, so we need
+      * only check the first digit.
+      */
+     if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
+         (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
+         (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
+     {
+#ifdef PNG_STDIO_SUPPORTED
+        char msg[80];
+        if (user_png_ver)
+        {
+           png_snprintf(msg, 80,
+              "Application was compiled with png.h from libpng-%.20s",
+              user_png_ver);
+           png_warning(png_ptr, msg);
+        }
+        png_snprintf(msg, 80,
+           "Application  is  running with png.c from libpng-%.20s",
+           png_libpng_ver);
+        png_warning(png_ptr, msg);
+#endif
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+        png_ptr->flags = 0;
+#endif
+        png_warning(png_ptr,
+           "Incompatible libpng version in application and library");
+        png_cleanup_needed = 1;
+     }
+   }
+
+   /* Initialize zbuf - compression buffer */
+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+   if (!png_cleanup_needed)
+   {
+      png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr,
+         png_ptr->zbuf_size);
+      if (png_ptr->zbuf == NULL)
+         png_cleanup_needed = 1;
+   }
+   if (png_cleanup_needed)
+   {
+       /* Clean up PNG structure and deallocate any memory. */
+       png_free(png_ptr, png_ptr->zbuf);
+       png_ptr->zbuf = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+       png_destroy_struct_2((png_voidp)png_ptr,
+          (png_free_ptr)free_fn, (png_voidp)mem_ptr);
+#else
+       png_destroy_struct((png_voidp)png_ptr);
+#endif
+       return (NULL);
+   }
+
+   png_set_write_fn(png_ptr, NULL, NULL, NULL);
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
+      1, NULL, NULL);
+#endif
+
+   return (png_ptr);
+}
+
+
+/* Write a few rows of image data.  If the image is interlaced,
+ * either you will have to write the 7 sub images, or, if you
+ * have called png_set_interlace_handling(), you will have to
+ * "write" the image seven times.
+ */
+void PNGAPI
+png_write_rows(png_structp png_ptr, png_bytepp row,
+   png_uint_32 num_rows)
+{
+   png_uint_32 i; /* row counter */
+   png_bytepp rp; /* row pointer */
+
+   png_debug(1, "in png_write_rows");
+
+   if (png_ptr == NULL)
+      return;
+
+   /* Loop through the rows */
+   for (i = 0, rp = row; i < num_rows; i++, rp++)
+   {
+      png_write_row(png_ptr, *rp);
+   }
+}
+
+/* Write the image.  You only need to call this function once, even
+ * if you are writing an interlaced image.
+ */
+void PNGAPI
+png_write_image(png_structp png_ptr, png_bytepp image)
+{
+   png_uint_32 i; /* row index */
+   int pass, num_pass; /* pass variables */
+   png_bytepp rp; /* points to current row */
+
+   if (png_ptr == NULL)
+      return;
+
+   png_debug(1, "in png_write_image");
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* Initialize interlace handling.  If image is not interlaced,
+    * this will set pass to 1
+    */
+   num_pass = png_set_interlace_handling(png_ptr);
+#else
+   num_pass = 1;
+#endif
+   /* Loop through passes */
+   for (pass = 0; pass < num_pass; pass++)
+   {
+      /* Loop through image */
+      for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
+      {
+         png_write_row(png_ptr, *rp);
+      }
+   }
+}
+
+/* Called by user to write a row of image data */
+void PNGAPI
+png_write_row(png_structp png_ptr, png_bytep row)
+{
+   if (png_ptr == NULL)
+      return;
+
+   png_debug2(1, "in png_write_row (row %ld, pass %d)",
+      png_ptr->row_number, png_ptr->pass);
+
+   /* Initialize transformations and other stuff if first time */
+   if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+   {
+      /* Make sure we wrote the header info */
+      if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
+         png_error(png_ptr,
+            "png_write_info was never called before png_write_row");
+
+      /* Check for transforms that have been set but were defined out */
+#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
+      if (png_ptr->transformations & PNG_INVERT_MONO)
+         png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
+#endif
+#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
+      if (png_ptr->transformations & PNG_FILLER)
+         png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
+#endif
+#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)
+      if (png_ptr->transformations & PNG_PACKSWAP)
+         png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
+#endif
+#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
+      if (png_ptr->transformations & PNG_PACK)
+         png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
+#endif
+#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
+      if (png_ptr->transformations & PNG_SHIFT)
+         png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
+#endif
+#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
+      if (png_ptr->transformations & PNG_BGR)
+         png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
+#endif
+#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
+      if (png_ptr->transformations & PNG_SWAP_BYTES)
+         png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
+#endif
+
+      png_write_start_row(png_ptr);
+   }
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* If interlaced and not interested in row, return */
+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
+   {
+      switch (png_ptr->pass)
+      {
+         case 0:
+            if (png_ptr->row_number & 0x07)
+            {
+               png_write_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 1:
+            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
+            {
+               png_write_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 2:
+            if ((png_ptr->row_number & 0x07) != 4)
+            {
+               png_write_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 3:
+            if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)
+            {
+               png_write_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 4:
+            if ((png_ptr->row_number & 0x03) != 2)
+            {
+               png_write_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 5:
+            if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)
+            {
+               png_write_finish_row(png_ptr);
+               return;
+            }
+            break;
+         case 6:
+            if (!(png_ptr->row_number & 0x01))
+            {
+               png_write_finish_row(png_ptr);
+               return;
+            }
+            break;
+      }
+   }
+#endif
+
+   /* Set up row info for transformations */
+   png_ptr->row_info.color_type = png_ptr->color_type;
+   png_ptr->row_info.width = png_ptr->usr_width;
+   png_ptr->row_info.channels = png_ptr->usr_channels;
+   png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
+   png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
+      png_ptr->row_info.channels);
+
+   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+      png_ptr->row_info.width);
+
+   png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type);
+   png_debug1(3, "row_info->width = %lu", png_ptr->row_info.width);
+   png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels);
+   png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth);
+   png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth);
+   png_debug1(3, "row_info->rowbytes = %lu", png_ptr->row_info.rowbytes);
+
+   /* Copy user's row into buffer, leaving room for filter byte. */
+   png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes);
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* Handle interlacing */
+   if (png_ptr->interlaced && png_ptr->pass < 6 &&
+      (png_ptr->transformations & PNG_INTERLACE))
+   {
+      png_do_write_interlace(&(png_ptr->row_info),
+         png_ptr->row_buf + 1, png_ptr->pass);
+      /* This should always get caught above, but still ... */
+      if (!(png_ptr->row_info.width))
+      {
+         png_write_finish_row(png_ptr);
+         return;
+      }
+   }
+#endif
+
+   /* Handle other transformations */
+   if (png_ptr->transformations)
+      png_do_write_transformations(png_ptr);
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   /* Write filter_method 64 (intrapixel differencing) only if
+    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
+    * 2. Libpng did not write a PNG signature (this filter_method is only
+    *    used in PNG datastreams that are embedded in MNG datastreams) and
+    * 3. The application called png_permit_mng_features with a mask that
+    *    included PNG_FLAG_MNG_FILTER_64 and
+    * 4. The filter_method is 64 and
+    * 5. The color_type is RGB or RGBA
+    */
+   if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
+   {
+      /* Intrapixel differencing */
+      png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
+   }
+#endif
+
+   /* Find a filter if necessary, filter the row and write it out. */
+   png_write_find_filter(png_ptr, &(png_ptr->row_info));
+
+   if (png_ptr->write_row_fn != NULL)
+      (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
+}
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+/* Set the automatic flush interval or 0 to turn flushing off */
+void PNGAPI
+png_set_flush(png_structp png_ptr, int nrows)
+{
+   png_debug(1, "in png_set_flush");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
+}
+
+/* Flush the current output buffers now */
+void PNGAPI
+png_write_flush(png_structp png_ptr)
+{
+   int wrote_IDAT;
+
+   png_debug(1, "in png_write_flush");
+
+   if (png_ptr == NULL)
+      return;
+   /* We have already written out all of the data */
+   if (png_ptr->row_number >= png_ptr->num_rows)
+      return;
+
+   do
+   {
+      int ret;
+
+      /* Compress the data */
+      ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
+      wrote_IDAT = 0;
+
+      /* Check for compression errors */
+      if (ret != Z_OK)
+      {
+         if (png_ptr->zstream.msg != NULL)
+            png_error(png_ptr, png_ptr->zstream.msg);
+         else
+            png_error(png_ptr, "zlib error");
+      }
+
+      if (!(png_ptr->zstream.avail_out))
+      {
+         /* Write the IDAT and reset the zlib output buffer */
+         png_write_IDAT(png_ptr, png_ptr->zbuf,
+                        png_ptr->zbuf_size);
+         png_ptr->zstream.next_out = png_ptr->zbuf;
+         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+         wrote_IDAT = 1;
+      }
+   } while(wrote_IDAT == 1);
+
+   /* If there is any data left to be output, write it into a new IDAT */
+   if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
+   {
+      /* Write the IDAT and reset the zlib output buffer */
+      png_write_IDAT(png_ptr, png_ptr->zbuf,
+                     png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+      png_ptr->zstream.next_out = png_ptr->zbuf;
+      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+   }
+   png_ptr->flush_rows = 0;
+   png_flush(png_ptr);
+}
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+
+/* Free all memory used by the write */
+void PNGAPI
+png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
+{
+   png_structp png_ptr = NULL;
+   png_infop info_ptr = NULL;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn = NULL;
+   png_voidp mem_ptr = NULL;
+#endif
+
+   png_debug(1, "in png_destroy_write_struct");
+
+   if (png_ptr_ptr != NULL)
+   {
+      png_ptr = *png_ptr_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+      free_fn = png_ptr->free_fn;
+      mem_ptr = png_ptr->mem_ptr;
+#endif
+   }
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr != NULL)
+   {
+      free_fn = png_ptr->free_fn;
+      mem_ptr = png_ptr->mem_ptr;
+   }
+#endif
+
+   if (info_ptr_ptr != NULL)
+      info_ptr = *info_ptr_ptr;
+
+   if (info_ptr != NULL)
+   {
+      if (png_ptr != NULL)
+      {
+        png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+        if (png_ptr->num_chunk_list)
+        {
+           png_free(png_ptr, png_ptr->chunk_list);
+           png_ptr->num_chunk_list = 0;
+        }
+#endif
+      }
+
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
+         (png_voidp)mem_ptr);
+#else
+      png_destroy_struct((png_voidp)info_ptr);
+#endif
+      *info_ptr_ptr = NULL;
+   }
+
+   if (png_ptr != NULL)
+   {
+      png_write_destroy(png_ptr);
+#ifdef PNG_USER_MEM_SUPPORTED
+      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
+         (png_voidp)mem_ptr);
+#else
+      png_destroy_struct((png_voidp)png_ptr);
+#endif
+      *png_ptr_ptr = NULL;
+   }
+}
+
+
+/* Free any memory used in png_ptr struct (old method) */
+void /* PRIVATE */
+png_write_destroy(png_structp png_ptr)
+{
+#ifdef PNG_SETJMP_SUPPORTED
+   jmp_buf tmp_jmp; /* Save jump buffer */
+#endif
+   png_error_ptr error_fn;
+   png_error_ptr warning_fn;
+   png_voidp error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_free_ptr free_fn;
+#endif
+
+   png_debug(1, "in png_write_destroy");
+
+   /* Free any memory zlib uses */
+   deflateEnd(&png_ptr->zstream);
+
+   /* Free our memory.  png_free checks NULL for us. */
+   png_free(png_ptr, png_ptr->zbuf);
+   png_free(png_ptr, png_ptr->row_buf);
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   png_free(png_ptr, png_ptr->prev_row);
+   png_free(png_ptr, png_ptr->sub_row);
+   png_free(png_ptr, png_ptr->up_row);
+   png_free(png_ptr, png_ptr->avg_row);
+   png_free(png_ptr, png_ptr->paeth_row);
+#endif
+
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+   png_free(png_ptr, png_ptr->time_buffer);
+#endif
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+   png_free(png_ptr, png_ptr->prev_filters);
+   png_free(png_ptr, png_ptr->filter_weights);
+   png_free(png_ptr, png_ptr->inv_filter_weights);
+   png_free(png_ptr, png_ptr->filter_costs);
+   png_free(png_ptr, png_ptr->inv_filter_costs);
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+   /* Reset structure */
+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
+#endif
+
+   error_fn = png_ptr->error_fn;
+   warning_fn = png_ptr->warning_fn;
+   error_ptr = png_ptr->error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   free_fn = png_ptr->free_fn;
+#endif
+
+   png_memset(png_ptr, 0, png_sizeof(png_struct));
+
+   png_ptr->error_fn = error_fn;
+   png_ptr->warning_fn = warning_fn;
+   png_ptr->error_ptr = error_ptr;
+#ifdef PNG_USER_MEM_SUPPORTED
+   png_ptr->free_fn = free_fn;
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
+#endif
+}
+
+/* Allow the application to select one or more row filters to use. */
+void PNGAPI
+png_set_filter(png_structp png_ptr, int method, int filters)
+{
+   png_debug(1, "in png_set_filter");
+
+   if (png_ptr == NULL)
+      return;
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+      (method == PNG_INTRAPIXEL_DIFFERENCING))
+         method = PNG_FILTER_TYPE_BASE;
+#endif
+   if (method == PNG_FILTER_TYPE_BASE)
+   {
+      switch (filters & (PNG_ALL_FILTERS | 0x07))
+      {
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+         case 5:
+         case 6:
+         case 7: png_warning(png_ptr, "Unknown row filter for method 0");
+#endif /* PNG_WRITE_FILTER_SUPPORTED */
+         case PNG_FILTER_VALUE_NONE:
+              png_ptr->do_filter = PNG_FILTER_NONE; break;
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+         case PNG_FILTER_VALUE_SUB:
+              png_ptr->do_filter = PNG_FILTER_SUB; break;
+         case PNG_FILTER_VALUE_UP:
+              png_ptr->do_filter = PNG_FILTER_UP; break;
+         case PNG_FILTER_VALUE_AVG:
+              png_ptr->do_filter = PNG_FILTER_AVG; break;
+         case PNG_FILTER_VALUE_PAETH:
+              png_ptr->do_filter = PNG_FILTER_PAETH; break;
+         default: png_ptr->do_filter = (png_byte)filters; break;
+#else
+         default: png_warning(png_ptr, "Unknown row filter for method 0");
+#endif /* PNG_WRITE_FILTER_SUPPORTED */
+      }
+
+      /* If we have allocated the row_buf, this means we have already started
+       * with the image and we should have allocated all of the filter buffers
+       * that have been selected.  If prev_row isn't already allocated, then
+       * it is too late to start using the filters that need it, since we
+       * will be missing the data in the previous row.  If an application
+       * wants to start and stop using particular filters during compression,
+       * it should start out with all of the filters, and then add and
+       * remove them after the start of compression.
+       */
+      if (png_ptr->row_buf != NULL)
+      {
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+         if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)
+         {
+            png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
+              (png_ptr->rowbytes + 1));
+            png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
+         }
+
+         if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)
+         {
+            if (png_ptr->prev_row == NULL)
+            {
+               png_warning(png_ptr, "Can't add Up filter after starting");
+               png_ptr->do_filter &= ~PNG_FILTER_UP;
+            }
+            else
+            {
+               png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
+                  (png_ptr->rowbytes + 1));
+               png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
+            }
+         }
+
+         if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)
+         {
+            if (png_ptr->prev_row == NULL)
+            {
+               png_warning(png_ptr, "Can't add Average filter after starting");
+               png_ptr->do_filter &= ~PNG_FILTER_AVG;
+            }
+            else
+            {
+               png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
+                  (png_ptr->rowbytes + 1));
+               png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
+            }
+         }
+
+         if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&
+             png_ptr->paeth_row == NULL)
+         {
+            if (png_ptr->prev_row == NULL)
+            {
+               png_warning(png_ptr, "Can't add Paeth filter after starting");
+               png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);
+            }
+            else
+            {
+               png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
+                  (png_ptr->rowbytes + 1));
+               png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
+            }
+         }
+
+         if (png_ptr->do_filter == PNG_NO_FILTERS)
+#endif /* PNG_WRITE_FILTER_SUPPORTED */
+            png_ptr->do_filter = PNG_FILTER_NONE;
+      }
+   }
+   else
+      png_error(png_ptr, "Unknown custom filter method");
+}
+
+/* This allows us to influence the way in which libpng chooses the "best"
+ * filter for the current scanline.  While the "minimum-sum-of-absolute-
+ * differences metric is relatively fast and effective, there is some
+ * question as to whether it can be improved upon by trying to keep the
+ * filtered data going to zlib more consistent, hopefully resulting in
+ * better compression.
+ */
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED      /* GRR 970116 */
+void PNGAPI
+png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
+   int num_weights, png_doublep filter_weights,
+   png_doublep filter_costs)
+{
+   int i;
+
+   png_debug(1, "in png_set_filter_heuristics");
+
+   if (png_ptr == NULL)
+      return;
+   if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)
+   {
+      png_warning(png_ptr, "Unknown filter heuristic method");
+      return;
+   }
+
+   if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)
+   {
+      heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;
+   }
+
+   if (num_weights < 0 || filter_weights == NULL ||
+      heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)
+   {
+      num_weights = 0;
+   }
+
+   png_ptr->num_prev_filters = (png_byte)num_weights;
+   png_ptr->heuristic_method = (png_byte)heuristic_method;
+
+   if (num_weights > 0)
+   {
+      if (png_ptr->prev_filters == NULL)
+      {
+         png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
+            (png_uint_32)(png_sizeof(png_byte) * num_weights));
+
+         /* To make sure that the weighting starts out fairly */
+         for (i = 0; i < num_weights; i++)
+         {
+            png_ptr->prev_filters[i] = 255;
+         }
+      }
+
+      if (png_ptr->filter_weights == NULL)
+      {
+         png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
+            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));
+
+         png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
+            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));
+         for (i = 0; i < num_weights; i++)
+         {
+            png_ptr->inv_filter_weights[i] =
+            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
+         }
+      }
+
+      for (i = 0; i < num_weights; i++)
+      {
+         if (filter_weights[i] < 0.0)
+         {
+            png_ptr->inv_filter_weights[i] =
+            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
+         }
+         else
+         {
+            png_ptr->inv_filter_weights[i] =
+               (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);
+            png_ptr->filter_weights[i] =
+               (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);
+         }
+      }
+   }
+
+   /* If, in the future, there are other filter methods, this would
+    * need to be based on png_ptr->filter.
+    */
+   if (png_ptr->filter_costs == NULL)
+   {
+      png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
+         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
+
+      png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
+         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
+
+      for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
+      {
+         png_ptr->inv_filter_costs[i] =
+         png_ptr->filter_costs[i] = PNG_COST_FACTOR;
+      }
+   }
+
+   /* Here is where we set the relative costs of the different filters.  We
+    * should take the desired compression level into account when setting
+    * the costs, so that Paeth, for instance, has a high relative cost at low
+    * compression levels, while it has a lower relative cost at higher
+    * compression settings.  The filter types are in order of increasing
+    * relative cost, so it would be possible to do this with an algorithm.
+    */
+   for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
+   {
+      if (filter_costs == NULL || filter_costs[i] < 0.0)
+      {
+         png_ptr->inv_filter_costs[i] =
+         png_ptr->filter_costs[i] = PNG_COST_FACTOR;
+      }
+      else if (filter_costs[i] >= 1.0)
+      {
+         png_ptr->inv_filter_costs[i] =
+            (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);
+         png_ptr->filter_costs[i] =
+            (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);
+      }
+   }
+}
+#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
+
+void PNGAPI
+png_set_compression_level(png_structp png_ptr, int level)
+{
+   png_debug(1, "in png_set_compression_level");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
+   png_ptr->zlib_level = level;
+}
+
+void PNGAPI
+png_set_compression_mem_level(png_structp png_ptr, int mem_level)
+{
+   png_debug(1, "in png_set_compression_mem_level");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
+   png_ptr->zlib_mem_level = mem_level;
+}
+
+void PNGAPI
+png_set_compression_strategy(png_structp png_ptr, int strategy)
+{
+   png_debug(1, "in png_set_compression_strategy");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
+   png_ptr->zlib_strategy = strategy;
+}
+
+void PNGAPI
+png_set_compression_window_bits(png_structp png_ptr, int window_bits)
+{
+   if (png_ptr == NULL)
+      return;
+   if (window_bits > 15)
+      png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
+   else if (window_bits < 8)
+      png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
+#ifndef WBITS_8_OK
+   /* Avoid libpng bug with 256-byte windows */
+   if (window_bits == 8)
+     {
+       png_warning(png_ptr, "Compression window is being reset to 512");
+       window_bits = 9;
+     }
+#endif
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
+   png_ptr->zlib_window_bits = window_bits;
+}
+
+void PNGAPI
+png_set_compression_method(png_structp png_ptr, int method)
+{
+   png_debug(1, "in png_set_compression_method");
+
+   if (png_ptr == NULL)
+      return;
+   if (method != 8)
+      png_warning(png_ptr, "Only compression method 8 is supported by PNG");
+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;
+   png_ptr->zlib_method = method;
+}
+
+void PNGAPI
+png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
+{
+   if (png_ptr == NULL)
+      return;
+   png_ptr->write_row_fn = write_row_fn;
+}
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+void PNGAPI
+png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
+   write_user_transform_fn)
+{
+   png_debug(1, "in png_set_write_user_transform_fn");
+
+   if (png_ptr == NULL)
+      return;
+   png_ptr->transformations |= PNG_USER_TRANSFORM;
+   png_ptr->write_user_transform_fn = write_user_transform_fn;
+}
+#endif
+
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+void PNGAPI
+png_write_png(png_structp png_ptr, png_infop info_ptr,
+              int transforms, voidp params)
+{
+   if (png_ptr == NULL || info_ptr == NULL)
+      return;
+
+   /* Write the file header information. */
+   png_write_info(png_ptr, info_ptr);
+
+   /* ------ these transformations don't touch the info structure ------- */
+
+#ifdef PNG_WRITE_INVERT_SUPPORTED
+   /* Invert monochrome pixels */
+   if (transforms & PNG_TRANSFORM_INVERT_MONO)
+      png_set_invert_mono(png_ptr);
+#endif
+
+#ifdef PNG_WRITE_SHIFT_SUPPORTED
+   /* Shift the pixels up to a legal bit depth and fill in
+    * as appropriate to correctly scale the image.
+    */
+   if ((transforms & PNG_TRANSFORM_SHIFT)
+               && (info_ptr->valid & PNG_INFO_sBIT))
+      png_set_shift(png_ptr, &info_ptr->sig_bit);
+#endif
+
+#ifdef PNG_WRITE_PACK_SUPPORTED
+   /* Pack pixels into bytes */
+   if (transforms & PNG_TRANSFORM_PACKING)
+       png_set_packing(png_ptr);
+#endif
+
+#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+   /* Swap location of alpha bytes from ARGB to RGBA */
+   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
+      png_set_swap_alpha(png_ptr);
+#endif
+
+#ifdef PNG_WRITE_FILLER_SUPPORTED
+   /* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */
+   if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)
+      png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
+   else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)
+      png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
+#endif
+
+#ifdef PNG_WRITE_BGR_SUPPORTED
+   /* Flip BGR pixels to RGB */
+   if (transforms & PNG_TRANSFORM_BGR)
+      png_set_bgr(png_ptr);
+#endif
+
+#ifdef PNG_WRITE_SWAP_SUPPORTED
+   /* Swap bytes of 16-bit files to most significant byte first */
+   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
+      png_set_swap(png_ptr);
+#endif
+
+#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
+   /* Swap bits of 1, 2, 4 bit packed pixel formats */
+   if (transforms & PNG_TRANSFORM_PACKSWAP)
+      png_set_packswap(png_ptr);
+#endif
+
+#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+   /* Invert the alpha channel from opacity to transparency */
+   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
+      png_set_invert_alpha(png_ptr);
+#endif
+
+   /* ----------------------- end of transformations ------------------- */
+
+   /* Write the bits */
+   if (info_ptr->valid & PNG_INFO_IDAT)
+       png_write_image(png_ptr, info_ptr->row_pointers);
+
+   /* It is REQUIRED to call this to finish writing the rest of the file */
+   png_write_end(png_ptr, info_ptr);
+
+   transforms = transforms; /* Quiet compiler warnings */
+   params = params;
+}
+#endif
+#endif /* PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pngwtran.c b/src/libpng/pngwtran.c
index 4b746cae0..9c8a6e7a9 100644
--- a/src/libpng/pngwtran.c
+++ b/src/libpng/pngwtran.c
@@ -1,581 +1,565 @@
-

-/* pngwtran.c - transforms the data in a row for PNG writers

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_WRITE_SUPPORTED

-

-/* Transform the data according to the user's wishes.  The order of

- * transformations is significant.

- */

-void /* PRIVATE */

-png_do_write_transformations(png_structp png_ptr)

-{

-   png_debug(1, "in png_do_write_transformations");

-

-   if (png_ptr == NULL)

-      return;

-

-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

-      if (png_ptr->write_user_transform_fn != NULL)

-        (*(png_ptr->write_user_transform_fn)) /* User write transform function */

-          (png_ptr,                    /* png_ptr */

-           &(png_ptr->row_info),       /* row_info:     */

-             /*  png_uint_32 width;          width of row */

-             /*  png_uint_32 rowbytes;       number of bytes in row */

-             /*  png_byte color_type;        color type of pixels */

-             /*  png_byte bit_depth;         bit depth of samples */

-             /*  png_byte channels;          number of channels (1-4) */

-             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */

-           png_ptr->row_buf + 1);      /* start of pixel data for row */

-#endif

-#ifdef PNG_WRITE_FILLER_SUPPORTED

-   if (png_ptr->transformations & PNG_FILLER)

-      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         png_ptr->flags);

-#endif

-#ifdef PNG_WRITE_PACKSWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_PACKSWAP)

-      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-#ifdef PNG_WRITE_PACK_SUPPORTED

-   if (png_ptr->transformations & PNG_PACK)

-      png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         (png_uint_32)png_ptr->bit_depth);

-#endif

-#ifdef PNG_WRITE_SWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_BYTES)

-      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-#ifdef PNG_WRITE_SHIFT_SUPPORTED

-   if (png_ptr->transformations & PNG_SHIFT)

-      png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         &(png_ptr->shift));

-#endif

-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_ALPHA)

-      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_ALPHA)

-      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-#ifdef PNG_WRITE_BGR_SUPPORTED

-   if (png_ptr->transformations & PNG_BGR)

-      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-#ifdef PNG_WRITE_INVERT_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_MONO)

-      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

-#endif

-}

-

-#ifdef PNG_WRITE_PACK_SUPPORTED

-/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The

- * row_info bit depth should be 8 (one pixel per byte).  The channels

- * should be 1 (this only happens on grayscale and paletted images).

- */

-void /* PRIVATE */

-png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)

-{

-   png_debug(1, "in png_do_pack");

-

-   if (row_info->bit_depth == 8 &&

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-      row_info->channels == 1)

-   {

-      switch ((int)bit_depth)

-      {

-         case 1:

-         {

-            png_bytep sp, dp;

-            int mask, v;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            sp = row;

-            dp = row;

-            mask = 0x80;

-            v = 0;

-

-            for (i = 0; i < row_width; i++)

-            {

-               if (*sp != 0)

-                  v |= mask;

-               sp++;

-               if (mask > 1)

-                  mask >>= 1;

-               else

-               {

-                  mask = 0x80;

-                  *dp = (png_byte)v;

-                  dp++;

-                  v = 0;

-               }

-            }

-            if (mask != 0x80)

-               *dp = (png_byte)v;

-            break;

-         }

-         case 2:

-         {

-            png_bytep sp, dp;

-            int shift, v;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            sp = row;

-            dp = row;

-            shift = 6;

-            v = 0;

-            for (i = 0; i < row_width; i++)

-            {

-               png_byte value;

-

-               value = (png_byte)(*sp & 0x03);

-               v |= (value << shift);

-               if (shift == 0)

-               {

-                  shift = 6;

-                  *dp = (png_byte)v;

-                  dp++;

-                  v = 0;

-               }

-               else

-                  shift -= 2;

-               sp++;

-            }

-            if (shift != 6)

-               *dp = (png_byte)v;

-            break;

-         }

-         case 4:

-         {

-            png_bytep sp, dp;

-            int shift, v;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            sp = row;

-            dp = row;

-            shift = 4;

-            v = 0;

-            for (i = 0; i < row_width; i++)

-            {

-               png_byte value;

-

-               value = (png_byte)(*sp & 0x0f);

-               v |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 4;

-                  *dp = (png_byte)v;

-                  dp++;

-                  v = 0;

-               }

-               else

-                  shift -= 4;

-

-               sp++;

-            }

-            if (shift != 4)

-               *dp = (png_byte)v;

-            break;

-         }

-      }

-      row_info->bit_depth = (png_byte)bit_depth;

-      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

-         row_info->width);

-   }

-}

-#endif

-

-#ifdef PNG_WRITE_SHIFT_SUPPORTED

-/* Shift pixel values to take advantage of whole range.  Pass the

- * true number of bits in bit_depth.  The row should be packed

- * according to row_info->bit_depth.  Thus, if you had a row of

- * bit depth 4, but the pixels only had values from 0 to 7, you

- * would pass 3 as bit_depth, and this routine would translate the

- * data to 0 to 15.

- */

-void /* PRIVATE */

-png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)

-{

-   png_debug(1, "in png_do_shift");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL &&

-#else

-   if (

-#endif

-      row_info->color_type != PNG_COLOR_TYPE_PALETTE)

-   {

-      int shift_start[4], shift_dec[4];

-      int channels = 0;

-

-      if (row_info->color_type & PNG_COLOR_MASK_COLOR)

-      {

-         shift_start[channels] = row_info->bit_depth - bit_depth->red;

-         shift_dec[channels] = bit_depth->red;

-         channels++;

-         shift_start[channels] = row_info->bit_depth - bit_depth->green;

-         shift_dec[channels] = bit_depth->green;

-         channels++;

-         shift_start[channels] = row_info->bit_depth - bit_depth->blue;

-         shift_dec[channels] = bit_depth->blue;

-         channels++;

-      }

-      else

-      {

-         shift_start[channels] = row_info->bit_depth - bit_depth->gray;

-         shift_dec[channels] = bit_depth->gray;

-         channels++;

-      }

-      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

-      {

-         shift_start[channels] = row_info->bit_depth - bit_depth->alpha;

-         shift_dec[channels] = bit_depth->alpha;

-         channels++;

-      }

-

-      /* With low row depths, could only be grayscale, so one channel */

-      if (row_info->bit_depth < 8)

-      {

-         png_bytep bp = row;

-         png_uint_32 i;

-         png_byte mask;

-         png_uint_32 row_bytes = row_info->rowbytes;

-

-         if (bit_depth->gray == 1 && row_info->bit_depth == 2)

-            mask = 0x55;

-         else if (row_info->bit_depth == 4 && bit_depth->gray == 3)

-            mask = 0x11;

-         else

-            mask = 0xff;

-

-         for (i = 0; i < row_bytes; i++, bp++)

-         {

-            png_uint_16 v;

-            int j;

-

-            v = *bp;

-            *bp = 0;

-            for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])

-            {

-               if (j > 0)

-                  *bp |= (png_byte)((v << j) & 0xff);

-               else

-                  *bp |= (png_byte)((v >> (-j)) & mask);

-            }

-         }

-      }

-      else if (row_info->bit_depth == 8)

-      {

-         png_bytep bp = row;

-         png_uint_32 i;

-         png_uint_32 istop = channels * row_info->width;

-

-         for (i = 0; i < istop; i++, bp++)

-         {

-

-            png_uint_16 v;

-            int j;

-            int c = (int)(i%channels);

-

-            v = *bp;

-            *bp = 0;

-            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

-            {

-               if (j > 0)

-                  *bp |= (png_byte)((v << j) & 0xff);

-               else

-                  *bp |= (png_byte)((v >> (-j)) & 0xff);

-            }

-         }

-      }

-      else

-      {

-         png_bytep bp;

-         png_uint_32 i;

-         png_uint_32 istop = channels * row_info->width;

-

-         for (bp = row, i = 0; i < istop; i++)

-         {

-            int c = (int)(i%channels);

-            png_uint_16 value, v;

-            int j;

-

-            v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));

-            value = 0;

-            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

-            {

-               if (j > 0)

-                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);

-               else

-                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);

-            }

-            *bp++ = (png_byte)(value >> 8);

-            *bp++ = (png_byte)(value & 0xff);

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

-void /* PRIVATE */

-png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_write_swap_alpha");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL)

-#endif

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This converts from ARGB to RGBA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               png_byte save = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save;

-            }

-         }

-         /* This converts from AARRGGBB to RRGGBBAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               png_byte save[2];

-               save[0] = *(sp++);

-               save[1] = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save[0];

-               *(dp++) = save[1];

-            }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This converts from AG to GA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               png_byte save = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save;

-            }

-         }

-         /* This converts from AAGG to GGAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               png_byte save[2];

-               save[0] = *(sp++);

-               save[1] = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save[0];

-               *(dp++) = save[1];

-            }

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-void /* PRIVATE */

-png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_write_invert_alpha");

-

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL)

-#endif

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This inverts the alpha channel in RGBA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               /* Does nothing

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               */

-               sp+=3; dp = sp;

-               *(dp++) = (png_byte)(255 - *(sp++));

-            }

-         }

-         /* This inverts the alpha channel in RRGGBBAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               /* Does nothing

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               */

-               sp+=6; dp = sp;

-               *(dp++) = (png_byte)(255 - *(sp++));

-               *(dp++) = (png_byte)(255 - *(sp++));

-            }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This inverts the alpha channel in GA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               *(dp++) = *(sp++);

-               *(dp++) = (png_byte)(255 - *(sp++));

-            }

-         }

-         /* This inverts the alpha channel in GGAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

-            {

-               /* Does nothing

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               */

-               sp+=2; dp = sp;

-               *(dp++) = (png_byte)(255 - *(sp++));

-               *(dp++) = (png_byte)(255 - *(sp++));

-            }

-         }

-      }

-   }

-}

-#endif

-

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-/* Undoes intrapixel differencing  */

-void /* PRIVATE */

-png_do_write_intrapixel(png_row_infop row_info, png_bytep row)

-{

-   png_debug(1, "in png_do_write_intrapixel");

-

-   if (

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-       row != NULL && row_info != NULL &&

-#endif

-       (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      int bytes_per_pixel;

-      png_uint_32 row_width = row_info->width;

-      if (row_info->bit_depth == 8)

-      {

-         png_bytep rp;

-         png_uint_32 i;

-

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-            bytes_per_pixel = 3;

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-            bytes_per_pixel = 4;

-         else

-            return;

-

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            *(rp)   = (png_byte)((*rp     - *(rp+1))&0xff);

-            *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         png_bytep rp;

-         png_uint_32 i;

-

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-            bytes_per_pixel = 6;

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-            bytes_per_pixel = 8;

-         else

-            return;

-

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);

-            png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);

-            png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);

-            png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);

-            png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);

-            *(rp  ) = (png_byte)((red >> 8) & 0xff);

-            *(rp+1) = (png_byte)(red & 0xff);

-            *(rp+4) = (png_byte)((blue >> 8) & 0xff);

-            *(rp+5) = (png_byte)(blue & 0xff);

-         }

-      }

-   }

-}

-#endif /* PNG_MNG_FEATURES_SUPPORTED */

-#endif /* PNG_WRITE_SUPPORTED */

+
+/* pngwtran.c - transforms the data in a row for PNG writers
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+#include "pngpriv.h"
+
+/* Transform the data according to the user's wishes.  The order of
+ * transformations is significant.
+ */
+void /* PRIVATE */
+png_do_write_transformations(png_structp png_ptr)
+{
+   png_debug(1, "in png_do_write_transformations");
+
+   if (png_ptr == NULL)
+      return;
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+      if (png_ptr->write_user_transform_fn != NULL)
+        (*(png_ptr->write_user_transform_fn)) /* User write transform function */
+          (png_ptr,                    /* png_ptr */
+           &(png_ptr->row_info),       /* row_info:     */
+             /*  png_uint_32 width;          width of row */
+             /*  png_uint_32 rowbytes;       number of bytes in row */
+             /*  png_byte color_type;        color type of pixels */
+             /*  png_byte bit_depth;         bit depth of samples */
+             /*  png_byte channels;          number of channels (1-4) */
+             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
+           png_ptr->row_buf + 1);      /* start of pixel data for row */
+#endif
+#ifdef PNG_WRITE_FILLER_SUPPORTED
+   if (png_ptr->transformations & PNG_FILLER)
+      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         png_ptr->flags);
+#endif
+#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#ifdef PNG_WRITE_PACK_SUPPORTED
+   if (png_ptr->transformations & PNG_PACK)
+      png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         (png_uint_32)png_ptr->bit_depth);
+#endif
+#ifdef PNG_WRITE_SWAP_SUPPORTED
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#ifdef PNG_WRITE_SHIFT_SUPPORTED
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
+         &(png_ptr->shift));
+#endif
+#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+   if (png_ptr->transformations & PNG_SWAP_ALPHA)
+      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+   if (png_ptr->transformations & PNG_INVERT_ALPHA)
+      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#ifdef PNG_WRITE_BGR_SUPPORTED
+   if (png_ptr->transformations & PNG_BGR)
+      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+#ifdef PNG_WRITE_INVERT_SUPPORTED
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
+#endif
+}
+
+#ifdef PNG_WRITE_PACK_SUPPORTED
+/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
+ * row_info bit depth should be 8 (one pixel per byte).  The channels
+ * should be 1 (this only happens on grayscale and paletted images).
+ */
+void /* PRIVATE */
+png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
+{
+   png_debug(1, "in png_do_pack");
+
+   if (row_info->bit_depth == 8 &&
+      row_info->channels == 1)
+   {
+      switch ((int)bit_depth)
+      {
+         case 1:
+         {
+            png_bytep sp, dp;
+            int mask, v;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            sp = row;
+            dp = row;
+            mask = 0x80;
+            v = 0;
+
+            for (i = 0; i < row_width; i++)
+            {
+               if (*sp != 0)
+                  v |= mask;
+               sp++;
+               if (mask > 1)
+                  mask >>= 1;
+               else
+               {
+                  mask = 0x80;
+                  *dp = (png_byte)v;
+                  dp++;
+                  v = 0;
+               }
+            }
+            if (mask != 0x80)
+               *dp = (png_byte)v;
+            break;
+         }
+         case 2:
+         {
+            png_bytep sp, dp;
+            int shift, v;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            sp = row;
+            dp = row;
+            shift = 6;
+            v = 0;
+            for (i = 0; i < row_width; i++)
+            {
+               png_byte value;
+
+               value = (png_byte)(*sp & 0x03);
+               v |= (value << shift);
+               if (shift == 0)
+               {
+                  shift = 6;
+                  *dp = (png_byte)v;
+                  dp++;
+                  v = 0;
+               }
+               else
+                  shift -= 2;
+               sp++;
+            }
+            if (shift != 6)
+               *dp = (png_byte)v;
+            break;
+         }
+         case 4:
+         {
+            png_bytep sp, dp;
+            int shift, v;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            sp = row;
+            dp = row;
+            shift = 4;
+            v = 0;
+            for (i = 0; i < row_width; i++)
+            {
+               png_byte value;
+
+               value = (png_byte)(*sp & 0x0f);
+               v |= (value << shift);
+
+               if (shift == 0)
+               {
+                  shift = 4;
+                  *dp = (png_byte)v;
+                  dp++;
+                  v = 0;
+               }
+               else
+                  shift -= 4;
+
+               sp++;
+            }
+            if (shift != 4)
+               *dp = (png_byte)v;
+            break;
+         }
+      }
+      row_info->bit_depth = (png_byte)bit_depth;
+      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
+         row_info->width);
+   }
+}
+#endif
+
+#ifdef PNG_WRITE_SHIFT_SUPPORTED
+/* Shift pixel values to take advantage of whole range.  Pass the
+ * true number of bits in bit_depth.  The row should be packed
+ * according to row_info->bit_depth.  Thus, if you had a row of
+ * bit depth 4, but the pixels only had values from 0 to 7, you
+ * would pass 3 as bit_depth, and this routine would translate the
+ * data to 0 to 15.
+ */
+void /* PRIVATE */
+png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
+{
+   png_debug(1, "in png_do_shift");
+
+   if (
+      row_info->color_type != PNG_COLOR_TYPE_PALETTE)
+   {
+      int shift_start[4], shift_dec[4];
+      int channels = 0;
+
+      if (row_info->color_type & PNG_COLOR_MASK_COLOR)
+      {
+         shift_start[channels] = row_info->bit_depth - bit_depth->red;
+         shift_dec[channels] = bit_depth->red;
+         channels++;
+         shift_start[channels] = row_info->bit_depth - bit_depth->green;
+         shift_dec[channels] = bit_depth->green;
+         channels++;
+         shift_start[channels] = row_info->bit_depth - bit_depth->blue;
+         shift_dec[channels] = bit_depth->blue;
+         channels++;
+      }
+      else
+      {
+         shift_start[channels] = row_info->bit_depth - bit_depth->gray;
+         shift_dec[channels] = bit_depth->gray;
+         channels++;
+      }
+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
+      {
+         shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
+         shift_dec[channels] = bit_depth->alpha;
+         channels++;
+      }
+
+      /* With low row depths, could only be grayscale, so one channel */
+      if (row_info->bit_depth < 8)
+      {
+         png_bytep bp = row;
+         png_uint_32 i;
+         png_byte mask;
+         png_uint_32 row_bytes = row_info->rowbytes;
+
+         if (bit_depth->gray == 1 && row_info->bit_depth == 2)
+            mask = 0x55;
+         else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
+            mask = 0x11;
+         else
+            mask = 0xff;
+
+         for (i = 0; i < row_bytes; i++, bp++)
+         {
+            png_uint_16 v;
+            int j;
+
+            v = *bp;
+            *bp = 0;
+            for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
+            {
+               if (j > 0)
+                  *bp |= (png_byte)((v << j) & 0xff);
+               else
+                  *bp |= (png_byte)((v >> (-j)) & mask);
+            }
+         }
+      }
+      else if (row_info->bit_depth == 8)
+      {
+         png_bytep bp = row;
+         png_uint_32 i;
+         png_uint_32 istop = channels * row_info->width;
+
+         for (i = 0; i < istop; i++, bp++)
+         {
+
+            png_uint_16 v;
+            int j;
+            int c = (int)(i%channels);
+
+            v = *bp;
+            *bp = 0;
+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+            {
+               if (j > 0)
+                  *bp |= (png_byte)((v << j) & 0xff);
+               else
+                  *bp |= (png_byte)((v >> (-j)) & 0xff);
+            }
+         }
+      }
+      else
+      {
+         png_bytep bp;
+         png_uint_32 i;
+         png_uint_32 istop = channels * row_info->width;
+
+         for (bp = row, i = 0; i < istop; i++)
+         {
+            int c = (int)(i%channels);
+            png_uint_16 value, v;
+            int j;
+
+            v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));
+            value = 0;
+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+            {
+               if (j > 0)
+                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
+               else
+                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
+            }
+            *bp++ = (png_byte)(value >> 8);
+            *bp++ = (png_byte)(value & 0xff);
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+void /* PRIVATE */
+png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_write_swap_alpha");
+
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         /* This converts from ARGB to RGBA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save;
+            }
+         }
+         /* This converts from AARRGGBB to RRGGBBAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save[2];
+               save[0] = *(sp++);
+               save[1] = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save[0];
+               *(dp++) = save[1];
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         /* This converts from AG to GA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save;
+            }
+         }
+         /* This converts from AAGG to GGAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               png_byte save[2];
+               save[0] = *(sp++);
+               save[1] = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = save[0];
+               *(dp++) = save[1];
+            }
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+void /* PRIVATE */
+png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_write_invert_alpha");
+
+   {
+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      {
+         /* This inverts the alpha channel in RGBA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               /* Does nothing
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               */
+               sp+=3; dp = sp;
+               *(dp++) = (png_byte)(255 - *(sp++));
+            }
+         }
+         /* This inverts the alpha channel in RRGGBBAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               /* Does nothing
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               */
+               sp+=6; dp = sp;
+               *(dp++) = (png_byte)(255 - *(sp++));
+               *(dp++) = (png_byte)(255 - *(sp++));
+            }
+         }
+      }
+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      {
+         /* This inverts the alpha channel in GA */
+         if (row_info->bit_depth == 8)
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               *(dp++) = *(sp++);
+               *(dp++) = (png_byte)(255 - *(sp++));
+            }
+         }
+         /* This inverts the alpha channel in GGAA */
+         else
+         {
+            png_bytep sp, dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            for (i = 0, sp = dp = row; i < row_width; i++)
+            {
+               /* Does nothing
+               *(dp++) = *(sp++);
+               *(dp++) = *(sp++);
+               */
+               sp+=2; dp = sp;
+               *(dp++) = (png_byte)(255 - *(sp++));
+               *(dp++) = (png_byte)(255 - *(sp++));
+            }
+         }
+      }
+   }
+}
+#endif
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+/* Undoes intrapixel differencing  */
+void /* PRIVATE */
+png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
+{
+   png_debug(1, "in png_do_write_intrapixel");
+
+   if (
+       (row_info->color_type & PNG_COLOR_MASK_COLOR))
+   {
+      int bytes_per_pixel;
+      png_uint_32 row_width = row_info->width;
+      if (row_info->bit_depth == 8)
+      {
+         png_bytep rp;
+         png_uint_32 i;
+
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+            bytes_per_pixel = 3;
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+            bytes_per_pixel = 4;
+         else
+            return;
+
+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+         {
+            *(rp)   = (png_byte)((*rp     - *(rp+1))&0xff);
+            *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);
+         }
+      }
+      else if (row_info->bit_depth == 16)
+      {
+         png_bytep rp;
+         png_uint_32 i;
+
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+            bytes_per_pixel = 6;
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+            bytes_per_pixel = 8;
+         else
+            return;
+
+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+         {
+            png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);
+            png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);
+            png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);
+            png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);
+            png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
+            *(rp  ) = (png_byte)((red >> 8) & 0xff);
+            *(rp+1) = (png_byte)(red & 0xff);
+            *(rp+4) = (png_byte)((blue >> 8) & 0xff);
+            *(rp+5) = (png_byte)(blue & 0xff);
+         }
+      }
+   }
+}
+#endif /* PNG_MNG_FEATURES_SUPPORTED */
+#endif /* PNG_WRITE_SUPPORTED */
diff --git a/src/libpng/pngwutil.c b/src/libpng/pngwutil.c
index a5712744f..eddac5b33 100644
--- a/src/libpng/pngwutil.c
+++ b/src/libpng/pngwutil.c
@@ -1,2828 +1,2783 @@
-

-/* pngwutil.c - utilities to write a PNG file

- *

- * Last changed in libpng 1.2.41 [December 3, 2009]

- * Copyright (c) 1998-2009 Glenn Randers-Pehrson

- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

- *

- * This code is released under the libpng license.

- * For conditions of distribution and use, see the disclaimer

- * and license in png.h

- */

-

-#define PNG_INTERNAL

-#define PNG_NO_PEDANTIC_WARNINGS

-#include "png.h"

-#ifdef PNG_WRITE_SUPPORTED

-

-/* Place a 32-bit number into a buffer in PNG byte order.  We work

- * with unsigned numbers for convenience, although one supported

- * ancillary chunk uses signed (two's complement) numbers.

- */

-void PNGAPI

-png_save_uint_32(png_bytep buf, png_uint_32 i)

-{

-   buf[0] = (png_byte)((i >> 24) & 0xff);

-   buf[1] = (png_byte)((i >> 16) & 0xff);

-   buf[2] = (png_byte)((i >> 8) & 0xff);

-   buf[3] = (png_byte)(i & 0xff);

-}

-

-/* The png_save_int_32 function assumes integers are stored in two's

- * complement format.  If this isn't the case, then this routine needs to

- * be modified to write data in two's complement format.

- */

-void PNGAPI

-png_save_int_32(png_bytep buf, png_int_32 i)

-{

-   buf[0] = (png_byte)((i >> 24) & 0xff);

-   buf[1] = (png_byte)((i >> 16) & 0xff);

-   buf[2] = (png_byte)((i >> 8) & 0xff);

-   buf[3] = (png_byte)(i & 0xff);

-}

-

-/* Place a 16-bit number into a buffer in PNG byte order.

- * The parameter is declared unsigned int, not png_uint_16,

- * just to avoid potential problems on pre-ANSI C compilers.

- */

-void PNGAPI

-png_save_uint_16(png_bytep buf, unsigned int i)

-{

-   buf[0] = (png_byte)((i >> 8) & 0xff);

-   buf[1] = (png_byte)(i & 0xff);

-}

-

-/* Simple function to write the signature.  If we have already written

- * the magic bytes of the signature, or more likely, the PNG stream is

- * being embedded into another stream and doesn't need its own signature,

- * we should call png_set_sig_bytes() to tell libpng how many of the

- * bytes have already been written.

- */

-void PNGAPI

-png_write_sig(png_structp png_ptr)

-{

-   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

-

-   /* Write the rest of the 8 byte signature */

-   png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],

-      (png_size_t)(8 - png_ptr->sig_bytes));

-   if (png_ptr->sig_bytes < 3)

-      png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

-}

-

-/* Write a PNG chunk all at once.  The type is an array of ASCII characters

- * representing the chunk name.  The array must be at least 4 bytes in

- * length, and does not need to be null terminated.  To be safe, pass the

- * pre-defined chunk names here, and if you need a new one, define it

- * where the others are defined.  The length is the length of the data.

- * All the data must be present.  If that is not possible, use the

- * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()

- * functions instead.

- */

-void PNGAPI

-png_write_chunk(png_structp png_ptr, png_bytep chunk_name,

-   png_bytep data, png_size_t length)

-{

-   if (png_ptr == NULL)

-      return;

-   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_end(png_ptr);

-}

-

-/* Write the start of a PNG chunk.  The type is the chunk type.

- * The total_length is the sum of the lengths of all the data you will be

- * passing in png_write_chunk_data().

- */

-void PNGAPI

-png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,

-   png_uint_32 length)

-{

-   png_byte buf[8];

-

-   png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,

-      (unsigned long)length);

-

-   if (png_ptr == NULL)

-      return;

-

-

-   /* Write the length and the chunk name */

-   png_save_uint_32(buf, length);

-   png_memcpy(buf + 4, chunk_name, 4);

-   png_write_data(png_ptr, buf, (png_size_t)8);

-   /* Put the chunk name into png_ptr->chunk_name */

-   png_memcpy(png_ptr->chunk_name, chunk_name, 4);

-   /* Reset the crc and run it over the chunk name */

-   png_reset_crc(png_ptr);

-   png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);

-}

-

-/* Write the data of a PNG chunk started with png_write_chunk_start().

- * Note that multiple calls to this function are allowed, and that the

- * sum of the lengths from these calls *must* add up to the total_length

- * given to png_write_chunk_start().

- */

-void PNGAPI

-png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-   /* Write the data, and run the CRC over it */

-   if (png_ptr == NULL)

-      return;

-   if (data != NULL && length > 0)

-   {

-      png_write_data(png_ptr, data, length);

-      /* Update the CRC after writing the data,

-       * in case that the user I/O routine alters it.

-       */

-      png_calculate_crc(png_ptr, data, length);

-   }

-}

-

-/* Finish a chunk started with png_write_chunk_start(). */

-void PNGAPI

-png_write_chunk_end(png_structp png_ptr)

-{

-   png_byte buf[4];

-

-   if (png_ptr == NULL) return;

-

-   /* Write the crc in a single operation */

-   png_save_uint_32(buf, png_ptr->crc);

-

-   png_write_data(png_ptr, buf, (png_size_t)4);

-}

-

-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)

-/* 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.

- * The compression_state structure is shared context for these functions

- * set up by the caller in order to make the whole mess thread-safe.

- */

-

-typedef struct

-{

-   char *input;   /* The uncompressed input data */

-   int input_len;   /* Its length */

-   int num_output_ptr; /* Number of output pointers used */

-   int max_output_ptr; /* Size of output_ptr */

-   png_charpp output_ptr; /* Array of pointers to output */

-} compression_state;

-

-/* Compress given text into storage in the png_ptr structure */

-static int /* PRIVATE */

-png_text_compress(png_structp png_ptr,

-        png_charp text, png_size_t text_len, int compression,

-        compression_state *comp)

-{

-   int ret;

-

-   comp->num_output_ptr = 0;

-   comp->max_output_ptr = 0;

-   comp->output_ptr = NULL;

-   comp->input = NULL;

-   comp->input_len = 0;

-

-   /* We may just want to pass the text right through */

-   if (compression == PNG_TEXT_COMPRESSION_NONE)

-   {

-       comp->input = text;

-       comp->input_len = text_len;

-       return((int)text_len);

-   }

-

-   if (compression >= PNG_TEXT_COMPRESSION_LAST)

-   {

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-      char msg[50];

-      png_snprintf(msg, 50, "Unknown compression type %d", compression);

-      png_warning(png_ptr, msg);

-#else

-      png_warning(png_ptr, "Unknown compression type");

-#endif

-   }

-

-   /* We can't write the chunk until we find out how much data we have,

-    * which means we need to run the compressor first and save the

-    * output.  This shouldn't be a problem, as the vast majority of

-    * comments should be reasonable, but we will set up an array of

-    * malloc'd pointers to be sure.

-    *

-    * If we knew the application was well behaved, we could simplify this

-    * greatly by assuming we can always malloc an output buffer large

-    * enough to hold the compressed text ((1001 * text_len / 1000) + 12)

-    * and malloc this directly.  The only time this would be a bad idea is

-    * if we can't malloc more than 64K and we have 64K of random input

-    * data, or if the input string is incredibly large (although this

-    * wouldn't cause a failure, just a slowdown due to swapping).

-    */

-

-   /* Set up the compression buffers */

-   png_ptr->zstream.avail_in = (uInt)text_len;

-   png_ptr->zstream.next_in = (Bytef *)text;

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-   png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;

-

-   /* This is the same compression loop as in png_write_row() */

-   do

-   {

-      /* Compress the data */

-      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

-      if (ret != Z_OK)

-      {

-         /* Error */

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-      /* Check to see if we need more room */

-      if (!(png_ptr->zstream.avail_out))

-      {

-         /* Make sure the output array has room */

-         if (comp->num_output_ptr >= comp->max_output_ptr)

-         {

-            int old_max;

-

-            old_max = comp->max_output_ptr;

-            comp->max_output_ptr = comp->num_output_ptr + 4;

-            if (comp->output_ptr != NULL)

-            {

-               png_charpp old_ptr;

-

-               old_ptr = comp->output_ptr;

-               comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                  (png_uint_32)

-                  (comp->max_output_ptr * png_sizeof(png_charpp)));

-               png_memcpy(comp->output_ptr, old_ptr, old_max

-                  * png_sizeof(png_charp));

-               png_free(png_ptr, old_ptr);

-            }

-            else

-               comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                  (png_uint_32)

-                  (comp->max_output_ptr * png_sizeof(png_charp)));

-         }

-

-         /* Save the data */

-         comp->output_ptr[comp->num_output_ptr] =

-            (png_charp)png_malloc(png_ptr,

-            (png_uint_32)png_ptr->zbuf_size);

-         png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

-            png_ptr->zbuf_size);

-         comp->num_output_ptr++;

-

-         /* and reset the buffer */

-         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-         png_ptr->zstream.next_out = png_ptr->zbuf;

-      }

-   /* Continue until we don't have any more to compress */

-   } while (png_ptr->zstream.avail_in);

-

-   /* Finish the compression */

-   do

-   {

-      /* Tell zlib we are finished */

-      ret = deflate(&png_ptr->zstream, Z_FINISH);

-

-      if (ret == Z_OK)

-      {

-         /* Check to see if we need more room */

-         if (!(png_ptr->zstream.avail_out))

-         {

-            /* Check to make sure our output array has room */

-            if (comp->num_output_ptr >= comp->max_output_ptr)

-            {

-               int old_max;

-

-               old_max = comp->max_output_ptr;

-               comp->max_output_ptr = comp->num_output_ptr + 4;

-               if (comp->output_ptr != NULL)

-               {

-                  png_charpp old_ptr;

-

-                  old_ptr = comp->output_ptr;

-                  /* This could be optimized to realloc() */

-                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                     (png_uint_32)(comp->max_output_ptr *

-                     png_sizeof(png_charp)));

-                  png_memcpy(comp->output_ptr, old_ptr,

-                     old_max * png_sizeof(png_charp));

-                  png_free(png_ptr, old_ptr);

-               }

-               else

-                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                     (png_uint_32)(comp->max_output_ptr *

-                     png_sizeof(png_charp)));

-            }

-

-            /* Save the data */

-            comp->output_ptr[comp->num_output_ptr] =

-               (png_charp)png_malloc(png_ptr,

-               (png_uint_32)png_ptr->zbuf_size);

-            png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

-               png_ptr->zbuf_size);

-            comp->num_output_ptr++;

-

-            /* and reset the buffer pointers */

-            png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-            png_ptr->zstream.next_out = png_ptr->zbuf;

-         }

-      }

-      else if (ret != Z_STREAM_END)

-      {

-         /* We got an error */

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-   } while (ret != Z_STREAM_END);

-

-   /* Text length is number of buffers plus last buffer */

-   text_len = png_ptr->zbuf_size * comp->num_output_ptr;

-   if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)

-      text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;

-

-   return((int)text_len);

-}

-

-/* Ship the compressed text out via chunk writes */

-static void /* PRIVATE */

-png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)

-{

-   int i;

-

-   /* Handle the no-compression case */

-   if (comp->input)

-   {

-      png_write_chunk_data(png_ptr, (png_bytep)comp->input,

-                            (png_size_t)comp->input_len);

-      return;

-   }

-

-   /* Write saved output buffers, if any */

-   for (i = 0; i < comp->num_output_ptr; i++)

-   {

-      png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],

-         (png_size_t)png_ptr->zbuf_size);

-      png_free(png_ptr, comp->output_ptr[i]);

-       comp->output_ptr[i]=NULL;

-   }

-   if (comp->max_output_ptr != 0)

-      png_free(png_ptr, comp->output_ptr);

-       comp->output_ptr=NULL;

-   /* Write anything left in zbuf */

-   if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)

-      png_write_chunk_data(png_ptr, png_ptr->zbuf,

-         (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));

-

-   /* Reset zlib for another zTXt/iTXt or image data */

-   deflateReset(&png_ptr->zstream);

-   png_ptr->zstream.data_type = Z_BINARY;

-}

-#endif

-

-/* Write the IHDR chunk, and update the png_struct with the necessary

- * information.  Note that the rest of this code depends upon this

- * information being correct.

- */

-void /* PRIVATE */

-png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,

-   int bit_depth, int color_type, int compression_type, int filter_type,

-   int interlace_type)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_IHDR;

-#endif

-   int ret;

-

-   png_byte buf[13]; /* Buffer to store the IHDR info */

-

-   png_debug(1, "in png_write_IHDR");

-

-   /* Check that we have valid input data from the application info */

-   switch (color_type)

-   {

-      case PNG_COLOR_TYPE_GRAY:

-         switch (bit_depth)

-         {

-            case 1:

-            case 2:

-            case 4:

-            case 8:

-            case 16: png_ptr->channels = 1; break;

-            default: png_error(png_ptr, "Invalid bit depth for grayscale image");

-         }

-         break;

-      case PNG_COLOR_TYPE_RGB:

-         if (bit_depth != 8 && bit_depth != 16)

-            png_error(png_ptr, "Invalid bit depth for RGB image");

-         png_ptr->channels = 3;

-         break;

-      case PNG_COLOR_TYPE_PALETTE:

-         switch (bit_depth)

-         {

-            case 1:

-            case 2:

-            case 4:

-            case 8: png_ptr->channels = 1; break;

-            default: png_error(png_ptr, "Invalid bit depth for paletted image");

-         }

-         break;

-      case PNG_COLOR_TYPE_GRAY_ALPHA:

-         if (bit_depth != 8 && bit_depth != 16)

-            png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");

-         png_ptr->channels = 2;

-         break;

-      case PNG_COLOR_TYPE_RGB_ALPHA:

-         if (bit_depth != 8 && bit_depth != 16)

-            png_error(png_ptr, "Invalid bit depth for RGBA image");

-         png_ptr->channels = 4;

-         break;

-      default:

-         png_error(png_ptr, "Invalid image color type specified");

-   }

-

-   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Invalid compression type specified");

-      compression_type = PNG_COMPRESSION_TYPE_BASE;

-   }

-

-   /* Write filter_method 64 (intrapixel differencing) only if

-    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

-    * 2. Libpng did not write a PNG signature (this filter_method is only

-    *    used in PNG datastreams that are embedded in MNG datastreams) and

-    * 3. The application called png_permit_mng_features with a mask that

-    *    included PNG_FLAG_MNG_FILTER_64 and

-    * 4. The filter_method is 64 and

-    * 5. The color_type is RGB or RGBA

-    */

-   if (

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-      !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

-      ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&

-      (color_type == PNG_COLOR_TYPE_RGB ||

-       color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

-      (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

-#endif

-      filter_type != PNG_FILTER_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Invalid filter type specified");

-      filter_type = PNG_FILTER_TYPE_BASE;

-   }

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   if (interlace_type != PNG_INTERLACE_NONE &&

-      interlace_type != PNG_INTERLACE_ADAM7)

-   {

-      png_warning(png_ptr, "Invalid interlace type specified");

-      interlace_type = PNG_INTERLACE_ADAM7;

-   }

-#else

-   interlace_type=PNG_INTERLACE_NONE;

-#endif

-

-   /* Save the relevent information */

-   png_ptr->bit_depth = (png_byte)bit_depth;

-   png_ptr->color_type = (png_byte)color_type;

-   png_ptr->interlaced = (png_byte)interlace_type;

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-   png_ptr->filter_type = (png_byte)filter_type;

-#endif

-   png_ptr->compression_type = (png_byte)compression_type;

-   png_ptr->width = width;

-   png_ptr->height = height;

-

-   png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);

-   png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);

-   /* Set the usr info, so any transformations can modify it */

-   png_ptr->usr_width = png_ptr->width;

-   png_ptr->usr_bit_depth = png_ptr->bit_depth;

-   png_ptr->usr_channels = png_ptr->channels;

-

-   /* Pack the header information into the buffer */

-   png_save_uint_32(buf, width);

-   png_save_uint_32(buf + 4, height);

-   buf[8] = (png_byte)bit_depth;

-   buf[9] = (png_byte)color_type;

-   buf[10] = (png_byte)compression_type;

-   buf[11] = (png_byte)filter_type;

-   buf[12] = (png_byte)interlace_type;

-

-   /* Write the chunk */

-   png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);

-

-   /* Initialize zlib with PNG info */

-   png_ptr->zstream.zalloc = png_zalloc;

-   png_ptr->zstream.zfree = png_zfree;

-   png_ptr->zstream.opaque = (voidpf)png_ptr;

-   if (!(png_ptr->do_filter))

-   {

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||

-         png_ptr->bit_depth < 8)

-         png_ptr->do_filter = PNG_FILTER_NONE;

-      else

-         png_ptr->do_filter = PNG_ALL_FILTERS;

-   }

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))

-   {

-      if (png_ptr->do_filter != PNG_FILTER_NONE)

-         png_ptr->zlib_strategy = Z_FILTERED;

-      else

-         png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;

-   }

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))

-      png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))

-      png_ptr->zlib_mem_level = 8;

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))

-      png_ptr->zlib_window_bits = 15;

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))

-      png_ptr->zlib_method = 8;

-   ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,

-         png_ptr->zlib_method, png_ptr->zlib_window_bits,

-         png_ptr->zlib_mem_level, png_ptr->zlib_strategy);

-   if (ret != Z_OK)

-   {

-      if (ret == Z_VERSION_ERROR) png_error(png_ptr,

-          "zlib failed to initialize compressor -- version error");

-      if (ret == Z_STREAM_ERROR) png_error(png_ptr,

-           "zlib failed to initialize compressor -- stream error");

-      if (ret == Z_MEM_ERROR) png_error(png_ptr,

-           "zlib failed to initialize compressor -- mem error");

-      png_error(png_ptr, "zlib failed to initialize compressor");

-   }

-   png_ptr->zstream.next_out = png_ptr->zbuf;

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-   /* libpng is not interested in zstream.data_type */

-   /* Set it to a predefined value, to avoid its evaluation inside zlib */

-   png_ptr->zstream.data_type = Z_BINARY;

-

-   png_ptr->mode = PNG_HAVE_IHDR;

-}

-

-/* 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

- * structure.

- */

-void /* PRIVATE */

-png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_PLTE;

-#endif

-   png_uint_32 i;

-   png_colorp pal_ptr;

-   png_byte buf[3];

-

-   png_debug(1, "in png_write_PLTE");

-

-   if ((

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-        !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&

-#endif

-        num_pal == 0) || num_pal > 256)

-   {

-     if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-     {

-        png_error(png_ptr, "Invalid number of colors in palette");

-     }

-     else

-     {

-        png_warning(png_ptr, "Invalid number of colors in palette");

-        return;

-     }

-   }

-

-   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))

-   {

-      png_warning(png_ptr,

-        "Ignoring request to write a PLTE chunk in grayscale PNG");

-      return;

-   }

-

-   png_ptr->num_palette = (png_uint_16)num_pal;

-   png_debug1(3, "num_palette = %d", png_ptr->num_palette);

-

-   png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,

-     (png_uint_32)(num_pal * 3));

-#ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)

-   {

-      buf[0] = pal_ptr->red;

-      buf[1] = pal_ptr->green;

-      buf[2] = pal_ptr->blue;

-      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

-   }

-#else

-   /* This is a little slower but some buggy compilers need to do this instead */

-   pal_ptr=palette;

-   for (i = 0; i < num_pal; i++)

-   {

-      buf[0] = pal_ptr[i].red;

-      buf[1] = pal_ptr[i].green;

-      buf[2] = pal_ptr[i].blue;

-      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

-   }

-#endif

-   png_write_chunk_end(png_ptr);

-   png_ptr->mode |= PNG_HAVE_PLTE;

-}

-

-/* Write an IDAT chunk */

-void /* PRIVATE */

-png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_IDAT;

-#endif

-

-   png_debug(1, "in png_write_IDAT");

-

-   /* Optimize the CMF field in the zlib stream. */

-   /* This hack of the zlib stream is compliant to the stream specification. */

-   if (!(png_ptr->mode & PNG_HAVE_IDAT) &&

-       png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)

-   {

-      unsigned int z_cmf = data[0];  /* zlib compression method and flags */

-      if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)

-      {

-         /* Avoid memory underflows and multiplication overflows.

-          *

-          * The conditions below are practically always satisfied;

-          * however, they still must be checked.

-          */

-         if (length >= 2 &&

-             png_ptr->height < 16384 && png_ptr->width < 16384)

-         {

-            png_uint_32 uncompressed_idat_size = png_ptr->height *

-               ((png_ptr->width *

-               png_ptr->channels * png_ptr->bit_depth + 15) >> 3);

-            unsigned int z_cinfo = z_cmf >> 4;

-            unsigned int half_z_window_size = 1 << (z_cinfo + 7);

-            while (uncompressed_idat_size <= half_z_window_size &&

-                   half_z_window_size >= 256)

-            {

-               z_cinfo--;

-               half_z_window_size >>= 1;

-            }

-            z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);

-            if (data[0] != (png_byte)z_cmf)

-            {

-               data[0] = (png_byte)z_cmf;

-               data[1] &= 0xe0;

-               data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);

-            }

-         }

-      }

-      else

-         png_error(png_ptr,

-            "Invalid zlib compression method or flags in IDAT");

-   }

-

-   png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);

-   png_ptr->mode |= PNG_HAVE_IDAT;

-}

-

-/* Write an IEND chunk */

-void /* PRIVATE */

-png_write_IEND(png_structp png_ptr)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_IEND;

-#endif

-

-   png_debug(1, "in png_write_IEND");

-

-   png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL,

-     (png_size_t)0);

-   png_ptr->mode |= PNG_HAVE_IEND;

-}

-

-#ifdef PNG_WRITE_gAMA_SUPPORTED

-/* Write a gAMA chunk */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-void /* PRIVATE */

-png_write_gAMA(png_structp png_ptr, double file_gamma)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_gAMA;

-#endif

-   png_uint_32 igamma;

-   png_byte buf[4];

-

-   png_debug(1, "in png_write_gAMA");

-

-   /* file_gamma is saved in 1/100,000ths */

-   igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);

-   png_save_uint_32(buf, igamma);

-   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

-}

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-void /* PRIVATE */

-png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_gAMA;

-#endif

-   png_byte buf[4];

-

-   png_debug(1, "in png_write_gAMA");

-

-   /* file_gamma is saved in 1/100,000ths */

-   png_save_uint_32(buf, (png_uint_32)file_gamma);

-   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

-}

-#endif

-#endif

-

-#ifdef PNG_WRITE_sRGB_SUPPORTED

-/* Write a sRGB chunk */

-void /* PRIVATE */

-png_write_sRGB(png_structp png_ptr, int srgb_intent)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_sRGB;

-#endif

-   png_byte buf[1];

-

-   png_debug(1, "in png_write_sRGB");

-

-   if (srgb_intent >= PNG_sRGB_INTENT_LAST)

-         png_warning(png_ptr,

-            "Invalid sRGB rendering intent specified");

-   buf[0]=(png_byte)srgb_intent;

-   png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);

-}

-#endif

-

-#ifdef PNG_WRITE_iCCP_SUPPORTED

-/* Write an iCCP chunk */

-void /* PRIVATE */

-png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,

-   png_charp profile, int profile_len)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_iCCP;

-#endif

-   png_size_t name_len;

-   png_charp new_name;

-   compression_state comp;

-   int embedded_profile_len = 0;

-

-   png_debug(1, "in png_write_iCCP");

-

-   comp.num_output_ptr = 0;

-   comp.max_output_ptr = 0;

-   comp.output_ptr = NULL;

-   comp.input = NULL;

-   comp.input_len = 0;

-

-   if ((name_len = png_check_keyword(png_ptr, name,

-      &new_name)) == 0)

-      return;

-

-   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

-      png_warning(png_ptr, "Unknown compression type in iCCP chunk");

-

-   if (profile == NULL)

-      profile_len = 0;

-

-   if (profile_len > 3)

-      embedded_profile_len =

-          ((*( (png_bytep)profile    ))<<24) |

-          ((*( (png_bytep)profile + 1))<<16) |

-          ((*( (png_bytep)profile + 2))<< 8) |

-          ((*( (png_bytep)profile + 3))    );

-

-   if (embedded_profile_len < 0)

-   {

-      png_warning(png_ptr,

-        "Embedded profile length in iCCP chunk is negative");

-      png_free(png_ptr, new_name);

-      return;

-   }

-

-   if (profile_len < embedded_profile_len)

-   {

-      png_warning(png_ptr,

-        "Embedded profile length too large in iCCP chunk");

-      png_free(png_ptr, new_name);

-      return;

-   }

-

-   if (profile_len > embedded_profile_len)

-   {

-      png_warning(png_ptr,

-        "Truncating profile to actual length in iCCP chunk");

-      profile_len = embedded_profile_len;

-   }

-

-   if (profile_len)

-      profile_len = png_text_compress(png_ptr, profile,

-        (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);

-

-   /* Make sure we include the NULL after the name and the compression type */

-   png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,

-          (png_uint_32)(name_len + profile_len + 2));

-   new_name[name_len + 1] = 0x00;

-   png_write_chunk_data(png_ptr, (png_bytep)new_name,

-     (png_size_t)(name_len + 2));

-

-   if (profile_len)

-      png_write_compressed_data_out(png_ptr, &comp);

-

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_name);

-}

-#endif

-

-#ifdef PNG_WRITE_sPLT_SUPPORTED

-/* Write a sPLT chunk */

-void /* PRIVATE */

-png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_sPLT;

-#endif

-   png_size_t name_len;

-   png_charp new_name;

-   png_byte entrybuf[10];

-   int entry_size = (spalette->depth == 8 ? 6 : 10);

-   int palette_size = entry_size * spalette->nentries;

-   png_sPLT_entryp ep;

-#ifndef PNG_POINTER_INDEXING_SUPPORTED

-   int i;

-#endif

-

-   png_debug(1, "in png_write_sPLT");

-

-   if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0)

-      return;

-

-   /* Make sure we include the NULL after the name */

-   png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,

-     (png_uint_32)(name_len + 2 + palette_size));

-   png_write_chunk_data(png_ptr, (png_bytep)new_name,

-     (png_size_t)(name_len + 1));

-   png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);

-

-   /* Loop through each palette entry, writing appropriately */

-#ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)

-   {

-      if (spalette->depth == 8)

-      {

-          entrybuf[0] = (png_byte)ep->red;

-          entrybuf[1] = (png_byte)ep->green;

-          entrybuf[2] = (png_byte)ep->blue;

-          entrybuf[3] = (png_byte)ep->alpha;

-          png_save_uint_16(entrybuf + 4, ep->frequency);

-      }

-      else

-      {

-          png_save_uint_16(entrybuf + 0, ep->red);

-          png_save_uint_16(entrybuf + 2, ep->green);

-          png_save_uint_16(entrybuf + 4, ep->blue);

-          png_save_uint_16(entrybuf + 6, ep->alpha);

-          png_save_uint_16(entrybuf + 8, ep->frequency);

-      }

-      png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

-   }

-#else

-   ep=spalette->entries;

-   for (i=0; i>spalette->nentries; i++)

-   {

-      if (spalette->depth == 8)

-      {

-          entrybuf[0] = (png_byte)ep[i].red;

-          entrybuf[1] = (png_byte)ep[i].green;

-          entrybuf[2] = (png_byte)ep[i].blue;

-          entrybuf[3] = (png_byte)ep[i].alpha;

-          png_save_uint_16(entrybuf + 4, ep[i].frequency);

-      }

-      else

-      {

-          png_save_uint_16(entrybuf + 0, ep[i].red);

-          png_save_uint_16(entrybuf + 2, ep[i].green);

-          png_save_uint_16(entrybuf + 4, ep[i].blue);

-          png_save_uint_16(entrybuf + 6, ep[i].alpha);

-          png_save_uint_16(entrybuf + 8, ep[i].frequency);

-      }

-      png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

-   }

-#endif

-

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_name);

-}

-#endif

-

-#ifdef PNG_WRITE_sBIT_SUPPORTED

-/* Write the sBIT chunk */

-void /* PRIVATE */

-png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_sBIT;

-#endif

-   png_byte buf[4];

-   png_size_t size;

-

-   png_debug(1, "in png_write_sBIT");

-

-   /* Make sure we don't depend upon the order of PNG_COLOR_8 */

-   if (color_type & PNG_COLOR_MASK_COLOR)

-   {

-      png_byte maxbits;

-

-      maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :

-                png_ptr->usr_bit_depth);

-      if (sbit->red == 0 || sbit->red > maxbits ||

-          sbit->green == 0 || sbit->green > maxbits ||

-          sbit->blue == 0 || sbit->blue > maxbits)

-      {

-         png_warning(png_ptr, "Invalid sBIT depth specified");

-         return;

-      }

-      buf[0] = sbit->red;

-      buf[1] = sbit->green;

-      buf[2] = sbit->blue;

-      size = 3;

-   }

-   else

-   {

-      if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)

-      {

-         png_warning(png_ptr, "Invalid sBIT depth specified");

-         return;

-      }

-      buf[0] = sbit->gray;

-      size = 1;

-   }

-

-   if (color_type & PNG_COLOR_MASK_ALPHA)

-   {

-      if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)

-      {

-         png_warning(png_ptr, "Invalid sBIT depth specified");

-         return;

-      }

-      buf[size++] = sbit->alpha;

-   }

-

-   png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);

-}

-#endif

-

-#ifdef PNG_WRITE_cHRM_SUPPORTED

-/* Write the cHRM chunk */

-#ifdef PNG_FLOATING_POINT_SUPPORTED

-void /* PRIVATE */

-png_write_cHRM(png_structp png_ptr, double white_x, double white_y,

-   double red_x, double red_y, double green_x, double green_y,

-   double blue_x, double blue_y)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_cHRM;

-#endif

-   png_byte buf[32];

-

-   png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y,

-      int_green_x, int_green_y, int_blue_x, int_blue_y;

-

-   png_debug(1, "in png_write_cHRM");

-

-   int_white_x = (png_uint_32)(white_x * 100000.0 + 0.5);

-   int_white_y = (png_uint_32)(white_y * 100000.0 + 0.5);

-   int_red_x   = (png_uint_32)(red_x   * 100000.0 + 0.5);

-   int_red_y   = (png_uint_32)(red_y   * 100000.0 + 0.5);

-   int_green_x = (png_uint_32)(green_x * 100000.0 + 0.5);

-   int_green_y = (png_uint_32)(green_y * 100000.0 + 0.5);

-   int_blue_x  = (png_uint_32)(blue_x  * 100000.0 + 0.5);

-   int_blue_y  = (png_uint_32)(blue_y  * 100000.0 + 0.5);

-

-#ifdef PNG_CHECK_cHRM_SUPPORTED

-   if (png_check_cHRM_fixed(png_ptr, int_white_x, int_white_y,

-      int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y))

-#endif

-   {

-      /* Each value is saved in 1/100,000ths */

-

-      png_save_uint_32(buf, int_white_x);

-      png_save_uint_32(buf + 4, int_white_y);

-

-      png_save_uint_32(buf + 8, int_red_x);

-      png_save_uint_32(buf + 12, int_red_y);

-

-      png_save_uint_32(buf + 16, int_green_x);

-      png_save_uint_32(buf + 20, int_green_y);

-

-      png_save_uint_32(buf + 24, int_blue_x);

-      png_save_uint_32(buf + 28, int_blue_y);

-

-      png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);

-   }

-}

-#endif

-#ifdef PNG_FIXED_POINT_SUPPORTED

-void /* PRIVATE */

-png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,

-   png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,

-   png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,

-   png_fixed_point blue_y)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_cHRM;

-#endif

-   png_byte buf[32];

-

-   png_debug(1, "in png_write_cHRM");

-

-   /* Each value is saved in 1/100,000ths */

-#ifdef PNG_CHECK_cHRM_SUPPORTED

-   if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,

-      green_x, green_y, blue_x, blue_y))

-#endif

-   {

-      png_save_uint_32(buf, (png_uint_32)white_x);

-      png_save_uint_32(buf + 4, (png_uint_32)white_y);

-

-      png_save_uint_32(buf + 8, (png_uint_32)red_x);

-      png_save_uint_32(buf + 12, (png_uint_32)red_y);

-

-      png_save_uint_32(buf + 16, (png_uint_32)green_x);

-      png_save_uint_32(buf + 20, (png_uint_32)green_y);

-

-      png_save_uint_32(buf + 24, (png_uint_32)blue_x);

-      png_save_uint_32(buf + 28, (png_uint_32)blue_y);

-

-      png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);

-   }

-}

-#endif

-#endif

-

-#ifdef PNG_WRITE_tRNS_SUPPORTED

-/* Write the tRNS chunk */

-void /* PRIVATE */

-png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,

-   int num_trans, int color_type)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_tRNS;

-#endif

-   png_byte buf[6];

-

-   png_debug(1, "in png_write_tRNS");

-

-   if (color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)

-      {

-         png_warning(png_ptr, "Invalid number of transparent colors specified");

-         return;

-      }

-      /* Write the chunk out as it is */

-      png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans,

-        (png_size_t)num_trans);

-   }

-   else if (color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      /* One 16 bit value */

-      if (tran->gray >= (1 << png_ptr->bit_depth))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");

-         return;

-      }

-      png_save_uint_16(buf, tran->gray);

-      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);

-   }

-   else if (color_type == PNG_COLOR_TYPE_RGB)

-   {

-      /* Three 16 bit values */

-      png_save_uint_16(buf, tran->red);

-      png_save_uint_16(buf + 2, tran->green);

-      png_save_uint_16(buf + 4, tran->blue);

-      if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");

-         return;

-      }

-      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);

-   }

-   else

-   {

-      png_warning(png_ptr, "Can't write tRNS with an alpha channel");

-   }

-}

-#endif

-

-#ifdef PNG_WRITE_bKGD_SUPPORTED

-/* Write the background chunk */

-void /* PRIVATE */

-png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_bKGD;

-#endif

-   png_byte buf[6];

-

-   png_debug(1, "in png_write_bKGD");

-

-   if (color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (

-#ifdef PNG_MNG_FEATURES_SUPPORTED

-          (png_ptr->num_palette ||

-          (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&

-#endif

-         back->index >= png_ptr->num_palette)

-      {

-         png_warning(png_ptr, "Invalid background palette index");

-         return;

-      }

-      buf[0] = back->index;

-      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);

-   }

-   else if (color_type & PNG_COLOR_MASK_COLOR)

-   {

-      png_save_uint_16(buf, back->red);

-      png_save_uint_16(buf + 2, back->green);

-      png_save_uint_16(buf + 4, back->blue);

-      if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");

-         return;

-      }

-      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);

-   }

-   else

-   {

-      if (back->gray >= (1 << png_ptr->bit_depth))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");

-         return;

-      }

-      png_save_uint_16(buf, back->gray);

-      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);

-   }

-}

-#endif

-

-#ifdef PNG_WRITE_hIST_SUPPORTED

-/* Write the histogram */

-void /* PRIVATE */

-png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_hIST;

-#endif

-   int i;

-   png_byte buf[3];

-

-   png_debug(1, "in png_write_hIST");

-

-   if (num_hist > (int)png_ptr->num_palette)

-   {

-      png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,

-         png_ptr->num_palette);

-      png_warning(png_ptr, "Invalid number of histogram entries specified");

-      return;

-   }

-

-   png_write_chunk_start(png_ptr, (png_bytep)png_hIST,

-     (png_uint_32)(num_hist * 2));

-   for (i = 0; i < num_hist; i++)

-   {

-      png_save_uint_16(buf, hist[i]);

-      png_write_chunk_data(png_ptr, buf, (png_size_t)2);

-   }

-   png_write_chunk_end(png_ptr);

-}

-#endif

-

-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \

-    defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

-/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,

- * and if invalid, correct the keyword rather than discarding the entire

- * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in

- * length, forbids leading or trailing whitespace, multiple internal spaces,

- * and the non-break space (0x80) from ISO 8859-1.  Returns keyword length.

- *

- * The new_key is allocated to hold the corrected keyword and must be freed

- * by the calling routine.  This avoids problems with trying to write to

- * static keywords without having to have duplicate copies of the strings.

- */

-png_size_t /* PRIVATE */

-png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)

-{

-   png_size_t key_len;

-   png_charp kp, dp;

-   int kflag;

-   int kwarn=0;

-

-   png_debug(1, "in png_check_keyword");

-

-   *new_key = NULL;

-

-   if (key == NULL || (key_len = png_strlen(key)) == 0)

-   {

-      png_warning(png_ptr, "zero length keyword");

-      return ((png_size_t)0);

-   }

-

-   png_debug1(2, "Keyword to be checked is '%s'", key);

-

-   *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));

-   if (*new_key == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while procesing keyword");

-      return ((png_size_t)0);

-   }

-

-   /* Replace non-printing characters with a blank and print a warning */

-   for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)

-   {

-      if ((png_byte)*kp < 0x20 ||

-         ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1))

-      {

-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE)

-         char msg[40];

-

-         png_snprintf(msg, 40,

-           "invalid keyword character 0x%02X", (png_byte)*kp);

-         png_warning(png_ptr, msg);

-#else

-         png_warning(png_ptr, "invalid character in keyword");

-#endif

-         *dp = ' ';

-      }

-      else

-      {

-         *dp = *kp;

-      }

-   }

-   *dp = '\0';

-

-   /* Remove any trailing white space. */

-   kp = *new_key + key_len - 1;

-   if (*kp == ' ')

-   {

-      png_warning(png_ptr, "trailing spaces removed from keyword");

-

-      while (*kp == ' ')

-      {

-         *(kp--) = '\0';

-         key_len--;

-      }

-   }

-

-   /* Remove any leading white space. */

-   kp = *new_key;

-   if (*kp == ' ')

-   {

-      png_warning(png_ptr, "leading spaces removed from keyword");

-

-      while (*kp == ' ')

-      {

-         kp++;

-         key_len--;

-      }

-   }

-

-   png_debug1(2, "Checking for multiple internal spaces in '%s'", kp);

-

-   /* Remove multiple internal spaces. */

-   for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)

-   {

-      if (*kp == ' ' && kflag == 0)

-      {

-         *(dp++) = *kp;

-         kflag = 1;

-      }

-      else if (*kp == ' ')

-      {

-         key_len--;

-         kwarn=1;

-      }

-      else

-      {

-         *(dp++) = *kp;

-         kflag = 0;

-      }

-   }

-   *dp = '\0';

-   if (kwarn)

-      png_warning(png_ptr, "extra interior spaces removed from keyword");

-

-   if (key_len == 0)

-   {

-      png_free(png_ptr, *new_key);

-       *new_key=NULL;

-      png_warning(png_ptr, "Zero length keyword");

-   }

-

-   if (key_len > 79)

-   {

-      png_warning(png_ptr, "keyword length must be 1 - 79 characters");

-      (*new_key)[79] = '\0';

-      key_len = 79;

-   }

-

-   return (key_len);

-}

-#endif

-

-#ifdef PNG_WRITE_tEXt_SUPPORTED

-/* Write a tEXt chunk */

-void /* PRIVATE */

-png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,

-   png_size_t text_len)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_tEXt;

-#endif

-   png_size_t key_len;

-   png_charp new_key;

-

-   png_debug(1, "in png_write_tEXt");

-

-   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)

-      return;

-

-   if (text == NULL || *text == '\0')

-      text_len = 0;

-   else

-      text_len = png_strlen(text);

-

-   /* Make sure we include the 0 after the key */

-   png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,

-      (png_uint_32)(key_len + text_len + 1));

-   /*

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

-    * 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.

-    */

-   png_write_chunk_data(png_ptr, (png_bytep)new_key,

-     (png_size_t)(key_len + 1));

-   if (text_len)

-      png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);

-

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_key);

-}

-#endif

-

-#ifdef PNG_WRITE_zTXt_SUPPORTED

-/* Write a compressed text chunk */

-void /* PRIVATE */

-png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,

-   png_size_t text_len, int compression)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_zTXt;

-#endif

-   png_size_t key_len;

-   char buf[1];

-   png_charp new_key;

-   compression_state comp;

-

-   png_debug(1, "in png_write_zTXt");

-

-   comp.num_output_ptr = 0;

-   comp.max_output_ptr = 0;

-   comp.output_ptr = NULL;

-   comp.input = NULL;

-   comp.input_len = 0;

-

-   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)

-   {

-      png_free(png_ptr, new_key);

-      return;

-   }

-

-   if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)

-   {

-      png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);

-      png_free(png_ptr, new_key);

-      return;

-   }

-

-   text_len = png_strlen(text);

-

-   /* Compute the compressed data; do it now for the length */

-   text_len = png_text_compress(png_ptr, text, text_len, compression,

-       &comp);

-

-   /* Write start of chunk */

-   png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,

-     (png_uint_32)(key_len+text_len + 2));

-   /* Write key */

-   png_write_chunk_data(png_ptr, (png_bytep)new_key,

-     (png_size_t)(key_len + 1));

-   png_free(png_ptr, new_key);

-

-   buf[0] = (png_byte)compression;

-   /* Write compression */

-   png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);

-   /* Write the compressed data */

-   png_write_compressed_data_out(png_ptr, &comp);

-

-   /* Close the chunk */

-   png_write_chunk_end(png_ptr);

-}

-#endif

-

-#ifdef PNG_WRITE_iTXt_SUPPORTED

-/* Write an iTXt chunk */

-void /* PRIVATE */

-png_write_iTXt(png_structp png_ptr, int compression, png_charp key,

-    png_charp lang, png_charp lang_key, png_charp text)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_iTXt;

-#endif

-   png_size_t lang_len, key_len, lang_key_len, text_len;

-   png_charp new_lang;

-   png_charp new_key = NULL;

-   png_byte cbuf[2];

-   compression_state comp;

-

-   png_debug(1, "in png_write_iTXt");

-

-   comp.num_output_ptr = 0;

-   comp.max_output_ptr = 0;

-   comp.output_ptr = NULL;

-   comp.input = NULL;

-

-   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)

-      return;

-

-   if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)

-   {

-      png_warning(png_ptr, "Empty language field in iTXt chunk");

-      new_lang = NULL;

-      lang_len = 0;

-   }

-

-   if (lang_key == NULL)

-      lang_key_len = 0;

-   else

-      lang_key_len = png_strlen(lang_key);

-

-   if (text == NULL)

-      text_len = 0;

-   else

-      text_len = png_strlen(text);

-

-   /* Compute the compressed data; do it now for the length */

-   text_len = png_text_compress(png_ptr, text, text_len, compression-2,

-      &comp);

-

-

-   /* Make sure we include the compression flag, the compression byte,

-    * and the NULs after the key, lang, and lang_key parts */

-

-   png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,

-          (png_uint_32)(

-        5 /* comp byte, comp flag, terminators for key, lang and lang_key */

-        + key_len

-        + lang_len

-        + lang_key_len

-        + text_len));

-

-   /* 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

-    * 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.

-    */

-   png_write_chunk_data(png_ptr, (png_bytep)new_key,

-     (png_size_t)(key_len + 1));

-

-   /* Set the compression flag */

-   if (compression == PNG_ITXT_COMPRESSION_NONE || \

-       compression == PNG_TEXT_COMPRESSION_NONE)

-       cbuf[0] = 0;

-   else /* compression == PNG_ITXT_COMPRESSION_zTXt */

-       cbuf[0] = 1;

-   /* Set the compression method */

-   cbuf[1] = 0;

-   png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);

-

-   cbuf[0] = 0;

-   png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),

-     (png_size_t)(lang_len + 1));

-   png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),

-     (png_size_t)(lang_key_len + 1));

-   png_write_compressed_data_out(png_ptr, &comp);

-

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_key);

-   png_free(png_ptr, new_lang);

-}

-#endif

-

-#ifdef PNG_WRITE_oFFs_SUPPORTED

-/* Write the oFFs chunk */

-void /* PRIVATE */

-png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,

-   int unit_type)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_oFFs;

-#endif

-   png_byte buf[9];

-

-   png_debug(1, "in png_write_oFFs");

-

-   if (unit_type >= PNG_OFFSET_LAST)

-      png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");

-

-   png_save_int_32(buf, x_offset);

-   png_save_int_32(buf + 4, y_offset);

-   buf[8] = (png_byte)unit_type;

-

-   png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);

-}

-#endif

-#ifdef PNG_WRITE_pCAL_SUPPORTED

-/* Write the pCAL chunk (described in the PNG extensions document) */

-void /* PRIVATE */

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

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_pCAL;

-#endif

-   png_size_t purpose_len, units_len, total_len;

-   png_uint_32p params_len;

-   png_byte buf[10];

-   png_charp new_purpose;

-   int i;

-

-   png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);

-

-   if (type >= PNG_EQUATION_LAST)

-      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

-

-   purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;

-   png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);

-   units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);

-   png_debug1(3, "pCAL units length = %d", (int)units_len);

-   total_len = purpose_len + units_len + 10;

-

-   params_len = (png_uint_32p)png_malloc(png_ptr,

-      (png_uint_32)(nparams * png_sizeof(png_uint_32)));

-

-   /* Find the length of each parameter, making sure we don't count the

-      null terminator for the last parameter. */

-   for (i = 0; i < nparams; i++)

-   {

-      params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);

-      png_debug2(3, "pCAL parameter %d length = %lu", i,

-        (unsigned long) params_len[i]);

-      total_len += (png_size_t)params_len[i];

-   }

-

-   png_debug1(3, "pCAL total length = %d", (int)total_len);

-   png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);

-   png_write_chunk_data(png_ptr, (png_bytep)new_purpose,

-     (png_size_t)purpose_len);

-   png_save_int_32(buf, X0);

-   png_save_int_32(buf + 4, X1);

-   buf[8] = (png_byte)type;

-   buf[9] = (png_byte)nparams;

-   png_write_chunk_data(png_ptr, buf, (png_size_t)10);

-   png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);

-

-   png_free(png_ptr, new_purpose);

-

-   for (i = 0; i < nparams; i++)

-   {

-      png_write_chunk_data(png_ptr, (png_bytep)params[i],

-         (png_size_t)params_len[i]);

-   }

-

-   png_free(png_ptr, params_len);

-   png_write_chunk_end(png_ptr);

-}

-#endif

-

-#ifdef PNG_WRITE_sCAL_SUPPORTED

-/* Write the sCAL chunk */

-#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)

-void /* PRIVATE */

-png_write_sCAL(png_structp png_ptr, int unit, double width, double height)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_sCAL;

-#endif

-   char buf[64];

-   png_size_t total_len;

-

-   png_debug(1, "in png_write_sCAL");

-

-   buf[0] = (char)unit;

-#ifdef _WIN32_WCE

-/* sprintf() function is not supported on WindowsCE */

-   {

-      wchar_t wc_buf[32];

-      size_t wc_len;

-      swprintf(wc_buf, TEXT("%12.12e"), width);

-      wc_len = wcslen(wc_buf);

-      WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + 1, wc_len, NULL, NULL);

-      total_len = wc_len + 2;

-      swprintf(wc_buf, TEXT("%12.12e"), height);

-      wc_len = wcslen(wc_buf);

-      WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + total_len, wc_len,

-         NULL, NULL);

-      total_len += wc_len;

-   }

-#else

-   png_snprintf(buf + 1, 63, "%12.12e", width);

-   total_len = 1 + png_strlen(buf + 1) + 1;

-   png_snprintf(buf + total_len, 64-total_len, "%12.12e", height);

-   total_len += png_strlen(buf + total_len);

-#endif

-

-   png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);

-   png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);

-}

-#else

-#ifdef PNG_FIXED_POINT_SUPPORTED

-void /* PRIVATE */

-png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,

-   png_charp height)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_sCAL;

-#endif

-   png_byte buf[64];

-   png_size_t wlen, hlen, total_len;

-

-   png_debug(1, "in png_write_sCAL_s");

-

-   wlen = png_strlen(width);

-   hlen = png_strlen(height);

-   total_len = wlen + hlen + 2;

-   if (total_len > 64)

-   {

-      png_warning(png_ptr, "Can't write sCAL (buffer too small)");

-      return;

-   }

-

-   buf[0] = (png_byte)unit;

-   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_debug1(3, "sCAL total length = %u", (unsigned int)total_len);

-   png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);

-}

-#endif

-#endif

-#endif

-

-#ifdef PNG_WRITE_pHYs_SUPPORTED

-/* Write the pHYs chunk */

-void /* PRIVATE */

-png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,

-   png_uint_32 y_pixels_per_unit,

-   int unit_type)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_pHYs;

-#endif

-   png_byte buf[9];

-

-   png_debug(1, "in png_write_pHYs");

-

-   if (unit_type >= PNG_RESOLUTION_LAST)

-      png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");

-

-   png_save_uint_32(buf, x_pixels_per_unit);

-   png_save_uint_32(buf + 4, y_pixels_per_unit);

-   buf[8] = (png_byte)unit_type;

-

-   png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);

-}

-#endif

-

-#ifdef PNG_WRITE_tIME_SUPPORTED

-/* Write the tIME chunk.  Use either png_convert_from_struct_tm()

- * or png_convert_from_time_t(), or fill in the structure yourself.

- */

-void /* PRIVATE */

-png_write_tIME(png_structp png_ptr, png_timep mod_time)

-{

-#ifdef PNG_USE_LOCAL_ARRAYS

-   PNG_tIME;

-#endif

-   png_byte buf[7];

-

-   png_debug(1, "in png_write_tIME");

-

-   if (mod_time->month  > 12 || mod_time->month  < 1 ||

-       mod_time->day    > 31 || mod_time->day    < 1 ||

-       mod_time->hour   > 23 || mod_time->second > 60)

-   {

-      png_warning(png_ptr, "Invalid time specified for tIME chunk");

-      return;

-   }

-

-   png_save_uint_16(buf, mod_time->year);

-   buf[2] = mod_time->month;

-   buf[3] = mod_time->day;

-   buf[4] = mod_time->hour;

-   buf[5] = mod_time->minute;

-   buf[6] = mod_time->second;

-

-   png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);

-}

-#endif

-

-/* Initializes the row writing capability of libpng */

-void /* PRIVATE */

-png_write_start_row(png_structp png_ptr)

-{

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-

-   /* Start of interlace block */

-   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

-

-   /* Offset to next interlace block */

-   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

-

-   /* Start of interlace block in the y direction */

-   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

-

-   /* Offset to next interlace block in the y direction */

-   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

-#endif

-

-   png_size_t buf_size;

-

-   png_debug(1, "in png_write_start_row");

-

-   buf_size = (png_size_t)(PNG_ROWBYTES(

-      png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);

-

-   /* Set up row buffer */

-   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,

-     (png_uint_32)buf_size);

-   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;

-

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-   /* Set up filtering buffer, if using this filter */

-   if (png_ptr->do_filter & PNG_FILTER_SUB)

-   {

-      png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

-         (png_uint_32)(png_ptr->rowbytes + 1));

-      png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

-   }

-

-   /* 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))

-   {

-      /* Set up previous row buffer */

-      png_ptr->prev_row = (png_bytep)png_calloc(png_ptr,

-         (png_uint_32)buf_size);

-

-      if (png_ptr->do_filter & PNG_FILTER_UP)

-      {

-         png_ptr->up_row = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(png_ptr->rowbytes + 1));

-         png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

-      }

-

-      if (png_ptr->do_filter & PNG_FILTER_AVG)

-      {

-         png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(png_ptr->rowbytes + 1));

-         png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

-      }

-

-      if (png_ptr->do_filter & PNG_FILTER_PAETH)

-      {

-         png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(png_ptr->rowbytes + 1));

-         png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

-      }

-   }

-#endif /* PNG_WRITE_FILTER_SUPPORTED */

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* If interlaced, we need to set up width and height of pass */

-   if (png_ptr->interlaced)

-   {

-      if (!(png_ptr->transformations & PNG_INTERLACE))

-      {

-         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

-            png_pass_ystart[0]) / png_pass_yinc[0];

-         png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -

-            png_pass_start[0]) / png_pass_inc[0];

-      }

-      else

-      {

-         png_ptr->num_rows = png_ptr->height;

-         png_ptr->usr_width = png_ptr->width;

-      }

-   }

-   else

-#endif

-   {

-      png_ptr->num_rows = png_ptr->height;

-      png_ptr->usr_width = png_ptr->width;

-   }

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-   png_ptr->zstream.next_out = png_ptr->zbuf;

-}

-

-/* Internal use only.  Called when finished processing a row of data. */

-void /* PRIVATE */

-png_write_finish_row(png_structp png_ptr)

-{

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-

-   /* Start of interlace block */

-   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

-

-   /* Offset to next interlace block */

-   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

-

-   /* Start of interlace block in the y direction */

-   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

-

-   /* Offset to next interlace block in the y direction */

-   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

-#endif

-

-   int ret;

-

-   png_debug(1, "in png_write_finish_row");

-

-   /* Next row */

-   png_ptr->row_number++;

-

-   /* See if we are done */

-   if (png_ptr->row_number < png_ptr->num_rows)

-      return;

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* If interlaced, go to next pass */

-   if (png_ptr->interlaced)

-   {

-      png_ptr->row_number = 0;

-      if (png_ptr->transformations & PNG_INTERLACE)

-      {

-         png_ptr->pass++;

-      }

-      else

-      {

-         /* Loop until we find a non-zero width or height pass */

-         do

-         {

-            png_ptr->pass++;

-            if (png_ptr->pass >= 7)

-               break;

-            png_ptr->usr_width = (png_ptr->width +

-               png_pass_inc[png_ptr->pass] - 1 -

-               png_pass_start[png_ptr->pass]) /

-               png_pass_inc[png_ptr->pass];

-            png_ptr->num_rows = (png_ptr->height +

-               png_pass_yinc[png_ptr->pass] - 1 -

-               png_pass_ystart[png_ptr->pass]) /

-               png_pass_yinc[png_ptr->pass];

-            if (png_ptr->transformations & PNG_INTERLACE)

-               break;

-         } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);

-

-      }

-

-      /* Reset the row above the image for the next pass */

-      if (png_ptr->pass < 7)

-      {

-         if (png_ptr->prev_row != NULL)

-            png_memset(png_ptr->prev_row, 0,

-               (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*

-               png_ptr->usr_bit_depth, png_ptr->width)) + 1);

-         return;

-      }

-   }

-#endif

-

-   /* If we get here, we've just written the last row, so we need

-      to flush the compressor */

-   do

-   {

-      /* Tell the compressor we are done */

-      ret = deflate(&png_ptr->zstream, Z_FINISH);

-      /* Check for an error */

-      if (ret == Z_OK)

-      {

-         /* Check to see if we need more room */

-         if (!(png_ptr->zstream.avail_out))

-         {

-            png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

-            png_ptr->zstream.next_out = png_ptr->zbuf;

-            png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-         }

-      }

-      else if (ret != Z_STREAM_END)

-      {

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-   } while (ret != Z_STREAM_END);

-

-   /* Write any extra space */

-   if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)

-   {

-      png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -

-         png_ptr->zstream.avail_out);

-   }

-

-   deflateReset(&png_ptr->zstream);

-   png_ptr->zstream.data_type = Z_BINARY;

-}

-

-#ifdef PNG_WRITE_INTERLACING_SUPPORTED

-/* Pick out the correct pixels for the interlace pass.

- * The basic idea here is to go through the row with a source

- * pointer and a destination pointer (sp and dp), and copy the

- * correct pixels for the pass.  As the row gets compacted,

- * sp will always be >= dp, so we should never overwrite anything.

- * See the default: case for the easiest code to understand.

- */

-void /* PRIVATE */

-png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)

-{

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-

-   /* Start of interlace block */

-   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

-

-   /* Offset to next interlace block */

-   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

-

-   png_debug(1, "in png_do_write_interlace");

-

-   /* We don't have to do anything on the last pass (6) */

-#ifdef PNG_USELESS_TESTS_SUPPORTED

-   if (row != NULL && row_info != NULL && pass < 6)

-#else

-   if (pass < 6)

-#endif

-   {

-      /* Each pixel depth is handled separately */

-      switch (row_info->pixel_depth)

-      {

-         case 1:

-         {

-            png_bytep sp;

-            png_bytep dp;

-            int shift;

-            int d;

-            int value;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            dp = row;

-            d = 0;

-            shift = 7;

-            for (i = png_pass_start[pass]; i < row_width;

-               i += png_pass_inc[pass])

-            {

-               sp = row + (png_size_t)(i >> 3);

-               value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;

-               d |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 7;

-                  *dp++ = (png_byte)d;

-                  d = 0;

-               }

-               else

-                  shift--;

-

-            }

-            if (shift != 7)

-               *dp = (png_byte)d;

-            break;

-         }

-         case 2:

-         {

-            png_bytep sp;

-            png_bytep dp;

-            int shift;

-            int d;

-            int value;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            dp = row;

-            shift = 6;

-            d = 0;

-            for (i = png_pass_start[pass]; i < row_width;

-               i += png_pass_inc[pass])

-            {

-               sp = row + (png_size_t)(i >> 2);

-               value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;

-               d |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 6;

-                  *dp++ = (png_byte)d;

-                  d = 0;

-               }

-               else

-                  shift -= 2;

-            }

-            if (shift != 6)

-                   *dp = (png_byte)d;

-            break;

-         }

-         case 4:

-         {

-            png_bytep sp;

-            png_bytep dp;

-            int shift;

-            int d;

-            int value;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            dp = row;

-            shift = 4;

-            d = 0;

-            for (i = png_pass_start[pass]; i < row_width;

-               i += png_pass_inc[pass])

-            {

-               sp = row + (png_size_t)(i >> 1);

-               value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;

-               d |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 4;

-                  *dp++ = (png_byte)d;

-                  d = 0;

-               }

-               else

-                  shift -= 4;

-            }

-            if (shift != 4)

-               *dp = (png_byte)d;

-            break;

-         }

-         default:

-         {

-            png_bytep sp;

-            png_bytep dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-            png_size_t pixel_bytes;

-

-            /* Start at the beginning */

-            dp = row;

-            /* Find out how many bytes each pixel takes up */

-            pixel_bytes = (row_info->pixel_depth >> 3);

-            /* Loop through the row, only looking at the pixels that

-               matter */

-            for (i = png_pass_start[pass]; i < row_width;

-               i += png_pass_inc[pass])

-            {

-               /* Find out where the original pixel is */

-               sp = row + (png_size_t)i * pixel_bytes;

-               /* Move the pixel */

-               if (dp != sp)

-                  png_memcpy(dp, sp, pixel_bytes);

-               /* Next pixel */

-               dp += pixel_bytes;

-            }

-            break;

-         }

-      }

-      /* Set new row width */

-      row_info->width = (row_info->width +

-         png_pass_inc[pass] - 1 -

-         png_pass_start[pass]) /

-         png_pass_inc[pass];

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

-            row_info->width);

-   }

-}

-#endif

-

-/* This filters the row, chooses which filter to use, if it has not already

- * been specified by the application, and then writes the row out with the

- * chosen filter.

- */

-#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)

-#define PNG_HISHIFT 10

-#define PNG_LOMASK ((png_uint_32)0xffffL)

-#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))

-void /* PRIVATE */

-png_write_find_filter(png_structp png_ptr, png_row_infop row_info)

-{

-   png_bytep best_row;

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-   png_bytep prev_row, row_buf;

-   png_uint_32 mins, bpp;

-   png_byte filter_to_do = png_ptr->do_filter;

-   png_uint_32 row_bytes = row_info->rowbytes;

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   int num_p_filters = (int)png_ptr->num_prev_filters;

-#endif 

-

-   png_debug(1, "in png_write_find_filter");

-

-#ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-  if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)

-  {

-      /* These will never be selected so we need not test them. */

-      filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH);

-  }

-#endif 

-

-   /* Find out how many bytes offset each pixel is */

-   bpp = (row_info->pixel_depth + 7) >> 3;

-

-   prev_row = png_ptr->prev_row;

-#endif

-   best_row = png_ptr->row_buf;

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-   row_buf = best_row;

-   mins = PNG_MAXSUM;

-

-   /* The prediction method we use is to find which method provides the

-    * smallest value when summing the absolute values of the distances

-    * from zero, using anything >= 128 as negative numbers.  This is known

-    * as the "minimum sum of absolute differences" heuristic.  Other

-    * heuristics are the "weighted minimum sum of absolute differences"

-    * (experimental and can in theory improve compression), and the "zlib

-    * predictive" method (not implemented yet), which does test compressions

-    * of lines using different filter methods, and then chooses the

-    * (series of) filter(s) that give minimum compressed data size (VERY

-    * computationally expensive).

-    *

-    * GRR 980525:  consider also

-    *   (1) minimum sum of absolute differences from running average (i.e.,

-    *       keep running sum of non-absolute differences & count of bytes)

-    *       [track dispersion, too?  restart average if dispersion too large?]

-    *  (1b) minimum sum of absolute differences from sliding average, probably

-    *       with window size <= deflate window (usually 32K)

-    *   (2) minimum sum of squared differences from zero or running average

-    *       (i.e., ~ root-mean-square approach)

-    */

-

-

-   /* We don't need to test the 'no filter' case if this is the only filter

-    * that has been chosen, as it doesn't actually do anything to the data.

-    */

-   if ((filter_to_do & PNG_FILTER_NONE) &&

-       filter_to_do != PNG_FILTER_NONE)

-   {

-      png_bytep rp;

-      png_uint_32 sum = 0;

-      png_uint_32 i;

-      int v;

-

-      for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)

-      {

-         v = *rp;

-         sum += (v < 128) ? v : 256 - v;

-      }

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         png_uint_32 sumhi, sumlo;

-         int j;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */

-

-         /* Reduce the sum if we match any of the previous rows */

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

-            {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         /* Factor in the cost of this filter (this is here for completeness,

-          * but it makes no sense to have a "cost" for the NONE filter, as

-          * it has the minimum possible computational cost - none).

-          */

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

-#endif

-      mins = sum;

-   }

-

-   /* Sub filter */

-   if (filter_to_do == PNG_FILTER_SUB)

-   /* It's the only filter so no testing is needed */

-   {

-      png_bytep rp, lp, dp;

-      png_uint_32 i;

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

-           i++, rp++, dp++)

-      {

-         *dp = *rp;

-      }

-      for (lp = row_buf + 1; i < row_bytes;

-         i++, rp++, lp++, dp++)

-      {

-         *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);

-      }

-      best_row = png_ptr->sub_row;

-   }

-

-   else if (filter_to_do & PNG_FILTER_SUB)

-   {

-      png_bytep rp, dp, lp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      /* We temporarily increase the "minimum sum" by the factor we

-       * would reduce the sum of this filter, so that we can do the

-       * early exit comparison without scaling the sum each time.

-       */

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

-            {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

-#endif

-

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

-           i++, rp++, dp++)

-      {

-         v = *dp = *rp;

-

-         sum += (v < 128) ? v : 256 - v;

-      }

-      for (lp = row_buf + 1; i < row_bytes;

-         i++, rp++, lp++, dp++)

-      {

-         v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);

-

-         sum += (v < 128) ? v : 256 - v;

-

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

-            {

-               sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

-#endif

-

-      if (sum < mins)

-      {

-         mins = sum;

-         best_row = png_ptr->sub_row;

-      }

-   }

-

-   /* Up filter */

-   if (filter_to_do == PNG_FILTER_UP)

-   {

-      png_bytep rp, dp, pp;

-      png_uint_32 i;

-

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

-           pp = prev_row + 1; i < row_bytes;

-           i++, rp++, pp++, dp++)

-      {

-         *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);

-      }

-      best_row = png_ptr->up_row;

-   }

-

-   else if (filter_to_do & PNG_FILTER_UP)

-   {

-      png_bytep rp, dp, pp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

-

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

-            {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

-#endif

-

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

-           pp = prev_row + 1; i < row_bytes; i++)

-      {

-         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

-

-         sum += (v < 128) ? v : 256 - v;

-

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

-            {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

-#endif

-

-      if (sum < mins)

-      {

-         mins = sum;

-         best_row = png_ptr->up_row;

-      }

-   }

-

-   /* Avg filter */

-   if (filter_to_do == PNG_FILTER_AVG)

-   {

-      png_bytep rp, dp, pp, lp;

-      png_uint_32 i;

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);

-      }

-      for (lp = row_buf + 1; i < row_bytes; i++)

-      {

-         *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))

-                 & 0xff);

-      }

-      best_row = png_ptr->avg_row;

-   }

-

-   else if (filter_to_do & PNG_FILTER_AVG)

-   {

-      png_bytep rp, dp, pp, lp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)

-            {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

-#endif

-

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);

-

-         sum += (v < 128) ? v : 256 - v;

-      }

-      for (lp = row_buf + 1; i < row_bytes; i++)

-      {

-         v = *dp++ =

-          (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);

-

-         sum += (v < 128) ? v : 256 - v;

-

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

-            {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

-#endif

-

-      if (sum < mins)

-      {

-         mins = sum;

-         best_row = png_ptr->avg_row;

-      }

-   }

-

-   /* Paeth filter */

-   if (filter_to_do == PNG_FILTER_PAETH)

-   {

-      png_bytep rp, dp, pp, cp, lp;

-      png_uint_32 i;

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

-      }

-

-      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

-      {

-         int a, b, c, pa, pb, pc, p;

-

-         b = *pp++;

-         c = *cp++;

-         a = *lp++;

-

-         p = b - c;

-         pc = a - c;

-

-#ifdef PNG_USE_ABS

-         pa = abs(p);

-         pb = abs(pc);

-         pc = abs(p + pc);

-#else

-         pa = p < 0 ? -p : p;

-         pb = pc < 0 ? -pc : pc;

-         pc = (p + pc) < 0 ? -(p + pc) : p + pc;

-#endif

-

-         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

-

-         *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);

-      }

-      best_row = png_ptr->paeth_row;

-   }

-

-   else if (filter_to_do & PNG_FILTER_PAETH)

-   {

-      png_bytep rp, dp, pp, cp, lp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

-            {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

-#endif

-

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

-

-         sum += (v < 128) ? v : 256 - v;

-      }

-

-      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

-      {

-         int a, b, c, pa, pb, pc, p;

-

-         b = *pp++;

-         c = *cp++;

-         a = *lp++;

-

-#ifndef PNG_SLOW_PAETH

-         p = b - c;

-         pc = a - c;

-#ifdef PNG_USE_ABS

-         pa = abs(p);

-         pb = abs(pc);

-         pc = abs(p + pc);

-#else

-         pa = p < 0 ? -p : p;

-         pb = pc < 0 ? -pc : pc;

-         pc = (p + pc) < 0 ? -(p + pc) : p + pc;

-#endif

-         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

-#else /* PNG_SLOW_PAETH */

-         p = a + b - c;

-         pa = abs(p - a);

-         pb = abs(p - b);

-         pc = abs(p - c);

-         if (pa <= pb && pa <= pc)

-            p = a;

-         else if (pb <= pc)

-            p = b;

-         else

-            p = c;

-#endif /* PNG_SLOW_PAETH */

-

-         v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);

-

-         sum += (v < 128) ? v : 256 - v;

-

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

-

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

-            {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-            }

-         }

-

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

-#endif

-

-      if (sum < mins)

-      {

-         best_row = png_ptr->paeth_row;

-      }

-   }

-#endif /* PNG_WRITE_FILTER_SUPPORTED */

-   /* Do the actual writing of the filtered row data from the chosen filter. */

-

-   png_write_filtered_row(png_ptr, best_row);

-

-#ifdef PNG_WRITE_FILTER_SUPPORTED

-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   /* Save the type of filter we picked this time for future calculations */

-   if (png_ptr->num_prev_filters > 0)

-   {

-      int j;

-      for (j = 1; j < num_p_filters; j++)

-      {

-         png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];

-      }

-      png_ptr->prev_filters[j] = best_row[0];

-   }

-#endif

-#endif /* PNG_WRITE_FILTER_SUPPORTED */

-}

-

-

-/* Do the actual writing of a previously filtered row. */

-void /* PRIVATE */

-png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)

-{

-   png_debug(1, "in png_write_filtered_row");

-

-   png_debug1(2, "filter = %d", filtered_row[0]);

-   /* Set up the zlib input buffer */

-

-   png_ptr->zstream.next_in = filtered_row;

-   png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;

-   /* Repeat until we have compressed all the data */

-   do

-   {

-      int ret; /* Return of zlib */

-

-      /* Compress the data */

-      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

-      /* Check for compression errors */

-      if (ret != Z_OK)

-      {

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-

-      /* See if it is time to write another IDAT */

-      if (!(png_ptr->zstream.avail_out))

-      {

-         /* Write the IDAT and reset the zlib output buffer */

-         png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

-         png_ptr->zstream.next_out = png_ptr->zbuf;

-         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-      }

-   /* Repeat until all data has been compressed */

-   } while (png_ptr->zstream.avail_in);

-

-   /* Swap the current and previous rows */

-   if (png_ptr->prev_row != NULL)

-   {

-      png_bytep tptr;

-

-      tptr = png_ptr->prev_row;

-      png_ptr->prev_row = png_ptr->row_buf;

-      png_ptr->row_buf = tptr;

-   }

-

-   /* Finish row - updates counters and flushes zlib if last row */

-   png_write_finish_row(png_ptr);

-

-#ifdef PNG_WRITE_FLUSH_SUPPORTED

-   png_ptr->flush_rows++;

-

-   if (png_ptr->flush_dist > 0 &&

-       png_ptr->flush_rows >= png_ptr->flush_dist)

-   {

-      png_write_flush(png_ptr);

-   }

-#endif

-}

-#endif /* PNG_WRITE_SUPPORTED */

+
+/* pngwutil.c - utilities to write a PNG file
+ *
+ * Last changed in libpng 1.4.0 [January 3, 2010]
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_WRITE_SUPPORTED
+#include "pngpriv.h"
+
+/* Place a 32-bit number into a buffer in PNG byte order.  We work
+ * with unsigned numbers for convenience, although one supported
+ * ancillary chunk uses signed (two's complement) numbers.
+ */
+void PNGAPI
+png_save_uint_32(png_bytep buf, png_uint_32 i)
+{
+   buf[0] = (png_byte)((i >> 24) & 0xff);
+   buf[1] = (png_byte)((i >> 16) & 0xff);
+   buf[2] = (png_byte)((i >> 8) & 0xff);
+   buf[3] = (png_byte)(i & 0xff);
+}
+
+#ifdef PNG_SAVE_INT_32_SUPPORTED
+/* The png_save_int_32 function assumes integers are stored in two's
+ * complement format.  If this isn't the case, then this routine needs to
+ * be modified to write data in two's complement format.
+ */
+void PNGAPI
+png_save_int_32(png_bytep buf, png_int_32 i)
+{
+   buf[0] = (png_byte)((i >> 24) & 0xff);
+   buf[1] = (png_byte)((i >> 16) & 0xff);
+   buf[2] = (png_byte)((i >> 8) & 0xff);
+   buf[3] = (png_byte)(i & 0xff);
+}
+#endif
+
+/* Place a 16-bit number into a buffer in PNG byte order.
+ * The parameter is declared unsigned int, not png_uint_16,
+ * just to avoid potential problems on pre-ANSI C compilers.
+ */
+void PNGAPI
+png_save_uint_16(png_bytep buf, unsigned int i)
+{
+   buf[0] = (png_byte)((i >> 8) & 0xff);
+   buf[1] = (png_byte)(i & 0xff);
+}
+
+/* Simple function to write the signature.  If we have already written
+ * the magic bytes of the signature, or more likely, the PNG stream is
+ * being embedded into another stream and doesn't need its own signature,
+ * we should call png_set_sig_bytes() to tell libpng how many of the
+ * bytes have already been written.
+ */
+void PNGAPI
+png_write_sig(png_structp png_ptr)
+{
+   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   /* Inform the I/O callback that the signature is being written */
+   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;
+#endif
+
+   /* Write the rest of the 8 byte signature */
+   png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
+      (png_size_t)(8 - png_ptr->sig_bytes));
+   if (png_ptr->sig_bytes < 3)
+      png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
+}
+
+/* Write a PNG chunk all at once.  The type is an array of ASCII characters
+ * representing the chunk name.  The array must be at least 4 bytes in
+ * length, and does not need to be null terminated.  To be safe, pass the
+ * pre-defined chunk names here, and if you need a new one, define it
+ * where the others are defined.  The length is the length of the data.
+ * All the data must be present.  If that is not possible, use the
+ * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
+ * functions instead.
+ */
+void PNGAPI
+png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
+   png_bytep data, png_size_t length)
+{
+   if (png_ptr == NULL)
+      return;
+   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_end(png_ptr);
+}
+
+/* Write the start of a PNG chunk.  The type is the chunk type.
+ * The total_length is the sum of the lengths of all the data you will be
+ * passing in png_write_chunk_data().
+ */
+void PNGAPI
+png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
+   png_uint_32 length)
+{
+   png_byte buf[8];
+
+   png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,
+      (unsigned long)length);
+
+   if (png_ptr == NULL)
+      return;
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   /* Inform the I/O callback that the chunk header is being written.
+    * PNG_IO_CHUNK_HDR requires a single I/O call.
+    */
+   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
+#endif
+
+   /* Write the length and the chunk name */
+   png_save_uint_32(buf, length);
+   png_memcpy(buf + 4, chunk_name, 4);
+   png_write_data(png_ptr, buf, (png_size_t)8);
+   /* Put the chunk name into png_ptr->chunk_name */
+   png_memcpy(png_ptr->chunk_name, chunk_name, 4);
+   /* Reset the crc and run it over the chunk name */
+   png_reset_crc(png_ptr);
+   png_calculate_crc(png_ptr, chunk_name, 4);
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   /* Inform the I/O callback that chunk data will (possibly) be written.
+    * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.
+    */
+   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;
+#endif
+}
+
+/* Write the data of a PNG chunk started with png_write_chunk_start().
+ * Note that multiple calls to this function are allowed, and that the
+ * sum of the lengths from these calls *must* add up to the total_length
+ * given to png_write_chunk_start().
+ */
+void PNGAPI
+png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   /* Write the data, and run the CRC over it */
+   if (png_ptr == NULL)
+      return;
+   if (data != NULL && length > 0)
+   {
+      png_write_data(png_ptr, data, length);
+      /* Update the CRC after writing the data,
+       * in case that the user I/O routine alters it.
+       */
+      png_calculate_crc(png_ptr, data, length);
+   }
+}
+
+/* Finish a chunk started with png_write_chunk_start(). */
+void PNGAPI
+png_write_chunk_end(png_structp png_ptr)
+{
+   png_byte buf[4];
+
+   if (png_ptr == NULL) return;
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   /* Inform the I/O callback that the chunk CRC is being written.
+    * PNG_IO_CHUNK_CRC requires a single I/O function call.
+    */
+   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
+#endif
+
+   /* Write the crc in a single operation */
+   png_save_uint_32(buf, png_ptr->crc);
+
+   png_write_data(png_ptr, buf, (png_size_t)4);
+}
+
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)
+/* 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.
+ * The compression_state structure is shared context for these functions
+ * set up by the caller in order to make the whole mess thread-safe.
+ */
+
+typedef struct
+{
+   char *input;   /* The uncompressed input data */
+   int input_len;   /* Its length */
+   int num_output_ptr; /* Number of output pointers used */
+   int max_output_ptr; /* Size of output_ptr */
+   png_charpp output_ptr; /* Array of pointers to output */
+} compression_state;
+
+/* Compress given text into storage in the png_ptr structure */
+static int /* PRIVATE */
+png_text_compress(png_structp png_ptr,
+        png_charp text, png_size_t text_len, int compression,
+        compression_state *comp)
+{
+   int ret;
+
+   comp->num_output_ptr = 0;
+   comp->max_output_ptr = 0;
+   comp->output_ptr = NULL;
+   comp->input = NULL;
+   comp->input_len = 0;
+
+   /* We may just want to pass the text right through */
+   if (compression == PNG_TEXT_COMPRESSION_NONE)
+   {
+       comp->input = text;
+       comp->input_len = text_len;
+       return((int)text_len);
+   }
+
+   if (compression >= PNG_TEXT_COMPRESSION_LAST)
+   {
+#ifdef PNG_STDIO_SUPPORTED
+      char msg[50];
+      png_snprintf(msg, 50, "Unknown compression type %d", compression);
+      png_warning(png_ptr, msg);
+#else
+      png_warning(png_ptr, "Unknown compression type");
+#endif
+   }
+
+   /* We can't write the chunk until we find out how much data we have,
+    * which means we need to run the compressor first and save the
+    * output.  This shouldn't be a problem, as the vast majority of
+    * comments should be reasonable, but we will set up an array of
+    * malloc'd pointers to be sure.
+    *
+    * If we knew the application was well behaved, we could simplify this
+    * greatly by assuming we can always malloc an output buffer large
+    * enough to hold the compressed text ((1001 * text_len / 1000) + 12)
+    * and malloc this directly.  The only time this would be a bad idea is
+    * if we can't malloc more than 64K and we have 64K of random input
+    * data, or if the input string is incredibly large (although this
+    * wouldn't cause a failure, just a slowdown due to swapping).
+    */
+
+   /* Set up the compression buffers */
+   png_ptr->zstream.avail_in = (uInt)text_len;
+   png_ptr->zstream.next_in = (Bytef *)text;
+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+   png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;
+
+   /* This is the same compression loop as in png_write_row() */
+   do
+   {
+      /* Compress the data */
+      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
+      if (ret != Z_OK)
+      {
+         /* Error */
+         if (png_ptr->zstream.msg != NULL)
+            png_error(png_ptr, png_ptr->zstream.msg);
+         else
+            png_error(png_ptr, "zlib error");
+      }
+      /* Check to see if we need more room */
+      if (!(png_ptr->zstream.avail_out))
+      {
+         /* Make sure the output array has room */
+         if (comp->num_output_ptr >= comp->max_output_ptr)
+         {
+            int old_max;
+
+            old_max = comp->max_output_ptr;
+            comp->max_output_ptr = comp->num_output_ptr + 4;
+            if (comp->output_ptr != NULL)
+            {
+               png_charpp old_ptr;
+
+               old_ptr = comp->output_ptr;
+               comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+                  (png_alloc_size_t)
+                  (comp->max_output_ptr * png_sizeof(png_charpp)));
+               png_memcpy(comp->output_ptr, old_ptr, old_max
+                  * png_sizeof(png_charp));
+               png_free(png_ptr, old_ptr);
+            }
+            else
+               comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+                  (png_alloc_size_t)
+                  (comp->max_output_ptr * png_sizeof(png_charp)));
+         }
+
+         /* Save the data */
+         comp->output_ptr[comp->num_output_ptr] =
+            (png_charp)png_malloc(png_ptr,
+            (png_alloc_size_t)png_ptr->zbuf_size);
+         png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
+            png_ptr->zbuf_size);
+         comp->num_output_ptr++;
+
+         /* and reset the buffer */
+         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+         png_ptr->zstream.next_out = png_ptr->zbuf;
+      }
+   /* Continue until we don't have any more to compress */
+   } while (png_ptr->zstream.avail_in);
+
+   /* Finish the compression */
+   do
+   {
+      /* Tell zlib we are finished */
+      ret = deflate(&png_ptr->zstream, Z_FINISH);
+
+      if (ret == Z_OK)
+      {
+         /* Check to see if we need more room */
+         if (!(png_ptr->zstream.avail_out))
+         {
+            /* Check to make sure our output array has room */
+            if (comp->num_output_ptr >= comp->max_output_ptr)
+            {
+               int old_max;
+
+               old_max = comp->max_output_ptr;
+               comp->max_output_ptr = comp->num_output_ptr + 4;
+               if (comp->output_ptr != NULL)
+               {
+                  png_charpp old_ptr;
+
+                  old_ptr = comp->output_ptr;
+                  /* This could be optimized to realloc() */
+                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+                     (png_alloc_size_t)(comp->max_output_ptr *
+                     png_sizeof(png_charp)));
+                  png_memcpy(comp->output_ptr, old_ptr,
+                     old_max * png_sizeof(png_charp));
+                  png_free(png_ptr, old_ptr);
+               }
+               else
+                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,
+                     (png_alloc_size_t)(comp->max_output_ptr *
+                     png_sizeof(png_charp)));
+            }
+
+            /* Save the data */
+            comp->output_ptr[comp->num_output_ptr] =
+               (png_charp)png_malloc(png_ptr,
+               (png_alloc_size_t)png_ptr->zbuf_size);
+            png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
+               png_ptr->zbuf_size);
+            comp->num_output_ptr++;
+
+            /* and reset the buffer pointers */
+            png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+            png_ptr->zstream.next_out = png_ptr->zbuf;
+         }
+      }
+      else if (ret != Z_STREAM_END)
+      {
+         /* We got an error */
+         if (png_ptr->zstream.msg != NULL)
+            png_error(png_ptr, png_ptr->zstream.msg);
+         else
+            png_error(png_ptr, "zlib error");
+      }
+   } while (ret != Z_STREAM_END);
+
+   /* Text length is number of buffers plus last buffer */
+   text_len = png_ptr->zbuf_size * comp->num_output_ptr;
+   if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
+      text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;
+
+   return((int)text_len);
+}
+
+/* Ship the compressed text out via chunk writes */
+static void /* PRIVATE */
+png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
+{
+   int i;
+
+   /* Handle the no-compression case */
+   if (comp->input)
+   {
+      png_write_chunk_data(png_ptr, (png_bytep)comp->input,
+                            (png_size_t)comp->input_len);
+      return;
+   }
+
+   /* Write saved output buffers, if any */
+   for (i = 0; i < comp->num_output_ptr; i++)
+   {
+      png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],
+         (png_size_t)png_ptr->zbuf_size);
+      png_free(png_ptr, comp->output_ptr[i]);
+   }
+   if (comp->max_output_ptr != 0)
+      png_free(png_ptr, comp->output_ptr);
+   /* Write anything left in zbuf */
+   if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
+      png_write_chunk_data(png_ptr, png_ptr->zbuf,
+         (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));
+
+   /* Reset zlib for another zTXt/iTXt or image data */
+   deflateReset(&png_ptr->zstream);
+   png_ptr->zstream.data_type = Z_BINARY;
+}
+#endif
+
+/* Write the IHDR chunk, and update the png_struct with the necessary
+ * information.  Note that the rest of this code depends upon this
+ * information being correct.
+ */
+void /* PRIVATE */
+png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
+   int bit_depth, int color_type, int compression_type, int filter_type,
+   int interlace_type)
+{
+   PNG_IHDR;
+   int ret;
+
+   png_byte buf[13]; /* Buffer to store the IHDR info */
+
+   png_debug(1, "in png_write_IHDR");
+
+   /* Check that we have valid input data from the application info */
+   switch (color_type)
+   {
+      case PNG_COLOR_TYPE_GRAY:
+         switch (bit_depth)
+         {
+            case 1:
+            case 2:
+            case 4:
+            case 8:
+            case 16: png_ptr->channels = 1; break;
+            default: png_error(png_ptr, "Invalid bit depth for grayscale image");
+         }
+         break;
+      case PNG_COLOR_TYPE_RGB:
+         if (bit_depth != 8 && bit_depth != 16)
+            png_error(png_ptr, "Invalid bit depth for RGB image");
+         png_ptr->channels = 3;
+         break;
+      case PNG_COLOR_TYPE_PALETTE:
+         switch (bit_depth)
+         {
+            case 1:
+            case 2:
+            case 4:
+            case 8: png_ptr->channels = 1; break;
+            default: png_error(png_ptr, "Invalid bit depth for paletted image");
+         }
+         break;
+      case PNG_COLOR_TYPE_GRAY_ALPHA:
+         if (bit_depth != 8 && bit_depth != 16)
+            png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
+         png_ptr->channels = 2;
+         break;
+      case PNG_COLOR_TYPE_RGB_ALPHA:
+         if (bit_depth != 8 && bit_depth != 16)
+            png_error(png_ptr, "Invalid bit depth for RGBA image");
+         png_ptr->channels = 4;
+         break;
+      default:
+         png_error(png_ptr, "Invalid image color type specified");
+   }
+
+   if (compression_type != PNG_COMPRESSION_TYPE_BASE)
+   {
+      png_warning(png_ptr, "Invalid compression type specified");
+      compression_type = PNG_COMPRESSION_TYPE_BASE;
+   }
+
+   /* Write filter_method 64 (intrapixel differencing) only if
+    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
+    * 2. Libpng did not write a PNG signature (this filter_method is only
+    *    used in PNG datastreams that are embedded in MNG datastreams) and
+    * 3. The application called png_permit_mng_features with a mask that
+    *    included PNG_FLAG_MNG_FILTER_64 and
+    * 4. The filter_method is 64 and
+    * 5. The color_type is RGB or RGBA
+    */
+   if (
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+      !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+      ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
+      (color_type == PNG_COLOR_TYPE_RGB ||
+       color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
+      (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
+#endif
+      filter_type != PNG_FILTER_TYPE_BASE)
+   {
+      png_warning(png_ptr, "Invalid filter type specified");
+      filter_type = PNG_FILTER_TYPE_BASE;
+   }
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   if (interlace_type != PNG_INTERLACE_NONE &&
+      interlace_type != PNG_INTERLACE_ADAM7)
+   {
+      png_warning(png_ptr, "Invalid interlace type specified");
+      interlace_type = PNG_INTERLACE_ADAM7;
+   }
+#else
+   interlace_type=PNG_INTERLACE_NONE;
+#endif
+
+   /* Save the relevent information */
+   png_ptr->bit_depth = (png_byte)bit_depth;
+   png_ptr->color_type = (png_byte)color_type;
+   png_ptr->interlaced = (png_byte)interlace_type;
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   png_ptr->filter_type = (png_byte)filter_type;
+#endif
+   png_ptr->compression_type = (png_byte)compression_type;
+   png_ptr->width = width;
+   png_ptr->height = height;
+
+   png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
+   png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
+   /* Set the usr info, so any transformations can modify it */
+   png_ptr->usr_width = png_ptr->width;
+   png_ptr->usr_bit_depth = png_ptr->bit_depth;
+   png_ptr->usr_channels = png_ptr->channels;
+
+   /* Pack the header information into the buffer */
+   png_save_uint_32(buf, width);
+   png_save_uint_32(buf + 4, height);
+   buf[8] = (png_byte)bit_depth;
+   buf[9] = (png_byte)color_type;
+   buf[10] = (png_byte)compression_type;
+   buf[11] = (png_byte)filter_type;
+   buf[12] = (png_byte)interlace_type;
+
+   /* Write the chunk */
+   png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
+
+   /* Initialize zlib with PNG info */
+   png_ptr->zstream.zalloc = png_zalloc;
+   png_ptr->zstream.zfree = png_zfree;
+   png_ptr->zstream.opaque = (voidpf)png_ptr;
+   if (!(png_ptr->do_filter))
+   {
+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
+         png_ptr->bit_depth < 8)
+         png_ptr->do_filter = PNG_FILTER_NONE;
+      else
+         png_ptr->do_filter = PNG_ALL_FILTERS;
+   }
+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))
+   {
+      if (png_ptr->do_filter != PNG_FILTER_NONE)
+         png_ptr->zlib_strategy = Z_FILTERED;
+      else
+         png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;
+   }
+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))
+      png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;
+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))
+      png_ptr->zlib_mem_level = 8;
+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))
+      png_ptr->zlib_window_bits = 15;
+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))
+      png_ptr->zlib_method = 8;
+   ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,
+         png_ptr->zlib_method, png_ptr->zlib_window_bits,
+         png_ptr->zlib_mem_level, png_ptr->zlib_strategy);
+   if (ret != Z_OK)
+   {
+      if (ret == Z_VERSION_ERROR) png_error(png_ptr,
+          "zlib failed to initialize compressor -- version error");
+      if (ret == Z_STREAM_ERROR) png_error(png_ptr,
+           "zlib failed to initialize compressor -- stream error");
+      if (ret == Z_MEM_ERROR) png_error(png_ptr,
+           "zlib failed to initialize compressor -- mem error");
+      png_error(png_ptr, "zlib failed to initialize compressor");
+   }
+   png_ptr->zstream.next_out = png_ptr->zbuf;
+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+   /* libpng is not interested in zstream.data_type */
+   /* Set it to a predefined value, to avoid its evaluation inside zlib */
+   png_ptr->zstream.data_type = Z_BINARY;
+
+   png_ptr->mode = PNG_HAVE_IHDR;
+}
+
+/* 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
+ * structure.
+ */
+void /* PRIVATE */
+png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
+{
+   PNG_PLTE;
+   png_uint_32 i;
+   png_colorp pal_ptr;
+   png_byte buf[3];
+
+   png_debug(1, "in png_write_PLTE");
+
+   if ((
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+        !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
+#endif
+        num_pal == 0) || num_pal > 256)
+   {
+     if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+     {
+        png_error(png_ptr, "Invalid number of colors in palette");
+     }
+     else
+     {
+        png_warning(png_ptr, "Invalid number of colors in palette");
+        return;
+     }
+   }
+
+   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
+   {
+      png_warning(png_ptr,
+        "Ignoring request to write a PLTE chunk in grayscale PNG");
+      return;
+   }
+
+   png_ptr->num_palette = (png_uint_16)num_pal;
+   png_debug1(3, "num_palette = %d", png_ptr->num_palette);
+
+   png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,
+     (png_uint_32)(num_pal * 3));
+#ifdef PNG_POINTER_INDEXING_SUPPORTED
+   for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
+   {
+      buf[0] = pal_ptr->red;
+      buf[1] = pal_ptr->green;
+      buf[2] = pal_ptr->blue;
+      png_write_chunk_data(png_ptr, buf, (png_size_t)3);
+   }
+#else
+   /* This is a little slower but some buggy compilers need to do this instead */
+   pal_ptr=palette;
+   for (i = 0; i < num_pal; i++)
+   {
+      buf[0] = pal_ptr[i].red;
+      buf[1] = pal_ptr[i].green;
+      buf[2] = pal_ptr[i].blue;
+      png_write_chunk_data(png_ptr, buf, (png_size_t)3);
+   }
+#endif
+   png_write_chunk_end(png_ptr);
+   png_ptr->mode |= PNG_HAVE_PLTE;
+}
+
+/* Write an IDAT chunk */
+void /* PRIVATE */
+png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   PNG_IDAT;
+
+   png_debug(1, "in png_write_IDAT");
+
+   /* Optimize the CMF field in the zlib stream. */
+   /* This hack of the zlib stream is compliant to the stream specification. */
+   if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
+       png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
+   {
+      unsigned int z_cmf = data[0];  /* zlib compression method and flags */
+      if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
+      {
+         /* Avoid memory underflows and multiplication overflows.
+          *
+          * The conditions below are practically always satisfied;
+          * however, they still must be checked.
+          */
+         if (length >= 2 &&
+             png_ptr->height < 16384 && png_ptr->width < 16384)
+         {
+            png_uint_32 uncompressed_idat_size = png_ptr->height *
+               ((png_ptr->width *
+               png_ptr->channels * png_ptr->bit_depth + 15) >> 3);
+            unsigned int z_cinfo = z_cmf >> 4;
+            unsigned int half_z_window_size = 1 << (z_cinfo + 7);
+            while (uncompressed_idat_size <= half_z_window_size &&
+                   half_z_window_size >= 256)
+            {
+               z_cinfo--;
+               half_z_window_size >>= 1;
+            }
+            z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
+            if (data[0] != (png_byte)z_cmf)
+            {
+               data[0] = (png_byte)z_cmf;
+               data[1] &= 0xe0;
+               data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);
+            }
+         }
+      }
+      else
+         png_error(png_ptr,
+            "Invalid zlib compression method or flags in IDAT");
+   }
+
+   png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);
+   png_ptr->mode |= PNG_HAVE_IDAT;
+}
+
+/* Write an IEND chunk */
+void /* PRIVATE */
+png_write_IEND(png_structp png_ptr)
+{
+   PNG_IEND;
+
+   png_debug(1, "in png_write_IEND");
+
+   png_write_chunk(png_ptr, (png_bytep)png_IEND, NULL,
+     (png_size_t)0);
+   png_ptr->mode |= PNG_HAVE_IEND;
+}
+
+#ifdef PNG_WRITE_gAMA_SUPPORTED
+/* Write a gAMA chunk */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_gAMA(png_structp png_ptr, double file_gamma)
+{
+   PNG_gAMA;
+   png_uint_32 igamma;
+   png_byte buf[4];
+
+   png_debug(1, "in png_write_gAMA");
+
+   /* file_gamma is saved in 1/100,000ths */
+   igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
+   png_save_uint_32(buf, igamma);
+   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
+{
+   PNG_gAMA;
+   png_byte buf[4];
+
+   png_debug(1, "in png_write_gAMA");
+
+   /* file_gamma is saved in 1/100,000ths */
+   png_save_uint_32(buf, (png_uint_32)file_gamma);
+   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
+}
+#endif
+#endif
+
+#ifdef PNG_WRITE_sRGB_SUPPORTED
+/* Write a sRGB chunk */
+void /* PRIVATE */
+png_write_sRGB(png_structp png_ptr, int srgb_intent)
+{
+   PNG_sRGB;
+   png_byte buf[1];
+
+   png_debug(1, "in png_write_sRGB");
+
+   if (srgb_intent >= PNG_sRGB_INTENT_LAST)
+         png_warning(png_ptr,
+            "Invalid sRGB rendering intent specified");
+   buf[0]=(png_byte)srgb_intent;
+   png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);
+}
+#endif
+
+#ifdef PNG_WRITE_iCCP_SUPPORTED
+/* Write an iCCP chunk */
+void /* PRIVATE */
+png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
+   png_charp profile, int profile_len)
+{
+   PNG_iCCP;
+   png_size_t name_len;
+   png_charp new_name;
+   compression_state comp;
+   int embedded_profile_len = 0;
+
+   png_debug(1, "in png_write_iCCP");
+
+   comp.num_output_ptr = 0;
+   comp.max_output_ptr = 0;
+   comp.output_ptr = NULL;
+   comp.input = NULL;
+   comp.input_len = 0;
+
+   if ((name_len = png_check_keyword(png_ptr, name,
+      &new_name)) == 0)
+      return;
+
+   if (compression_type != PNG_COMPRESSION_TYPE_BASE)
+      png_warning(png_ptr, "Unknown compression type in iCCP chunk");
+
+   if (profile == NULL)
+      profile_len = 0;
+
+   if (profile_len > 3)
+      embedded_profile_len =
+          ((*( (png_bytep)profile    ))<<24) |
+          ((*( (png_bytep)profile + 1))<<16) |
+          ((*( (png_bytep)profile + 2))<< 8) |
+          ((*( (png_bytep)profile + 3))    );
+
+   if (embedded_profile_len < 0)
+   {
+      png_warning(png_ptr,
+        "Embedded profile length in iCCP chunk is negative");
+      png_free(png_ptr, new_name);
+      return;
+   }
+
+   if (profile_len < embedded_profile_len)
+   {
+      png_warning(png_ptr,
+        "Embedded profile length too large in iCCP chunk");
+      png_free(png_ptr, new_name);
+      return;
+   }
+
+   if (profile_len > embedded_profile_len)
+   {
+      png_warning(png_ptr,
+        "Truncating profile to actual length in iCCP chunk");
+      profile_len = embedded_profile_len;
+   }
+
+   if (profile_len)
+      profile_len = png_text_compress(png_ptr, profile,
+        (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
+
+   /* Make sure we include the NULL after the name and the compression type */
+   png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,
+          (png_uint_32)(name_len + profile_len + 2));
+   new_name[name_len + 1] = 0x00;
+   png_write_chunk_data(png_ptr, (png_bytep)new_name,
+     (png_size_t)(name_len + 2));
+
+   if (profile_len)
+      png_write_compressed_data_out(png_ptr, &comp);
+
+   png_write_chunk_end(png_ptr);
+   png_free(png_ptr, new_name);
+}
+#endif
+
+#ifdef PNG_WRITE_sPLT_SUPPORTED
+/* Write a sPLT chunk */
+void /* PRIVATE */
+png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
+{
+   PNG_sPLT;
+   png_size_t name_len;
+   png_charp new_name;
+   png_byte entrybuf[10];
+   png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);
+   png_size_t palette_size = entry_size * spalette->nentries;
+   png_sPLT_entryp ep;
+#ifndef PNG_POINTER_INDEXING_SUPPORTED
+   int i;
+#endif
+
+   png_debug(1, "in png_write_sPLT");
+
+   if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0)
+      return;
+
+   /* Make sure we include the NULL after the name */
+   png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,
+     (png_uint_32)(name_len + 2 + palette_size));
+   png_write_chunk_data(png_ptr, (png_bytep)new_name,
+     (png_size_t)(name_len + 1));
+   png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);
+
+   /* Loop through each palette entry, writing appropriately */
+#ifdef PNG_POINTER_INDEXING_SUPPORTED
+   for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
+   {
+      if (spalette->depth == 8)
+      {
+          entrybuf[0] = (png_byte)ep->red;
+          entrybuf[1] = (png_byte)ep->green;
+          entrybuf[2] = (png_byte)ep->blue;
+          entrybuf[3] = (png_byte)ep->alpha;
+          png_save_uint_16(entrybuf + 4, ep->frequency);
+      }
+      else
+      {
+          png_save_uint_16(entrybuf + 0, ep->red);
+          png_save_uint_16(entrybuf + 2, ep->green);
+          png_save_uint_16(entrybuf + 4, ep->blue);
+          png_save_uint_16(entrybuf + 6, ep->alpha);
+          png_save_uint_16(entrybuf + 8, ep->frequency);
+      }
+      png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
+   }
+#else
+   ep=spalette->entries;
+   for (i=0; i>spalette->nentries; i++)
+   {
+      if (spalette->depth == 8)
+      {
+          entrybuf[0] = (png_byte)ep[i].red;
+          entrybuf[1] = (png_byte)ep[i].green;
+          entrybuf[2] = (png_byte)ep[i].blue;
+          entrybuf[3] = (png_byte)ep[i].alpha;
+          png_save_uint_16(entrybuf + 4, ep[i].frequency);
+      }
+      else
+      {
+          png_save_uint_16(entrybuf + 0, ep[i].red);
+          png_save_uint_16(entrybuf + 2, ep[i].green);
+          png_save_uint_16(entrybuf + 4, ep[i].blue);
+          png_save_uint_16(entrybuf + 6, ep[i].alpha);
+          png_save_uint_16(entrybuf + 8, ep[i].frequency);
+      }
+      png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
+   }
+#endif
+
+   png_write_chunk_end(png_ptr);
+   png_free(png_ptr, new_name);
+}
+#endif
+
+#ifdef PNG_WRITE_sBIT_SUPPORTED
+/* Write the sBIT chunk */
+void /* PRIVATE */
+png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
+{
+   PNG_sBIT;
+   png_byte buf[4];
+   png_size_t size;
+
+   png_debug(1, "in png_write_sBIT");
+
+   /* Make sure we don't depend upon the order of PNG_COLOR_8 */
+   if (color_type & PNG_COLOR_MASK_COLOR)
+   {
+      png_byte maxbits;
+
+      maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
+                png_ptr->usr_bit_depth);
+      if (sbit->red == 0 || sbit->red > maxbits ||
+          sbit->green == 0 || sbit->green > maxbits ||
+          sbit->blue == 0 || sbit->blue > maxbits)
+      {
+         png_warning(png_ptr, "Invalid sBIT depth specified");
+         return;
+      }
+      buf[0] = sbit->red;
+      buf[1] = sbit->green;
+      buf[2] = sbit->blue;
+      size = 3;
+   }
+   else
+   {
+      if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
+      {
+         png_warning(png_ptr, "Invalid sBIT depth specified");
+         return;
+      }
+      buf[0] = sbit->gray;
+      size = 1;
+   }
+
+   if (color_type & PNG_COLOR_MASK_ALPHA)
+   {
+      if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
+      {
+         png_warning(png_ptr, "Invalid sBIT depth specified");
+         return;
+      }
+      buf[size++] = sbit->alpha;
+   }
+
+   png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);
+}
+#endif
+
+#ifdef PNG_WRITE_cHRM_SUPPORTED
+/* Write the cHRM chunk */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
+   double red_x, double red_y, double green_x, double green_y,
+   double blue_x, double blue_y)
+{
+   PNG_cHRM;
+   png_byte buf[32];
+
+   png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y,
+      int_green_x, int_green_y, int_blue_x, int_blue_y;
+
+   png_debug(1, "in png_write_cHRM");
+
+   int_white_x = (png_uint_32)(white_x * 100000.0 + 0.5);
+   int_white_y = (png_uint_32)(white_y * 100000.0 + 0.5);
+   int_red_x   = (png_uint_32)(red_x   * 100000.0 + 0.5);
+   int_red_y   = (png_uint_32)(red_y   * 100000.0 + 0.5);
+   int_green_x = (png_uint_32)(green_x * 100000.0 + 0.5);
+   int_green_y = (png_uint_32)(green_y * 100000.0 + 0.5);
+   int_blue_x  = (png_uint_32)(blue_x  * 100000.0 + 0.5);
+   int_blue_y  = (png_uint_32)(blue_y  * 100000.0 + 0.5);
+
+#ifdef PNG_CHECK_cHRM_SUPPORTED
+   if (png_check_cHRM_fixed(png_ptr, int_white_x, int_white_y,
+      int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y))
+#endif
+   {
+      /* Each value is saved in 1/100,000ths */
+
+      png_save_uint_32(buf, int_white_x);
+      png_save_uint_32(buf + 4, int_white_y);
+
+      png_save_uint_32(buf + 8, int_red_x);
+      png_save_uint_32(buf + 12, int_red_y);
+
+      png_save_uint_32(buf + 16, int_green_x);
+      png_save_uint_32(buf + 20, int_green_y);
+
+      png_save_uint_32(buf + 24, int_blue_x);
+      png_save_uint_32(buf + 28, int_blue_y);
+
+      png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
+   }
+}
+#endif
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
+   png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,
+   png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,
+   png_fixed_point blue_y)
+{
+   PNG_cHRM;
+   png_byte buf[32];
+
+   png_debug(1, "in png_write_cHRM");
+
+   /* Each value is saved in 1/100,000ths */
+#ifdef PNG_CHECK_cHRM_SUPPORTED
+   if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,
+      green_x, green_y, blue_x, blue_y))
+#endif
+   {
+      png_save_uint_32(buf, (png_uint_32)white_x);
+      png_save_uint_32(buf + 4, (png_uint_32)white_y);
+
+      png_save_uint_32(buf + 8, (png_uint_32)red_x);
+      png_save_uint_32(buf + 12, (png_uint_32)red_y);
+
+      png_save_uint_32(buf + 16, (png_uint_32)green_x);
+      png_save_uint_32(buf + 20, (png_uint_32)green_y);
+
+      png_save_uint_32(buf + 24, (png_uint_32)blue_x);
+      png_save_uint_32(buf + 28, (png_uint_32)blue_y);
+
+      png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
+   }
+}
+#endif
+#endif
+
+#ifdef PNG_WRITE_tRNS_SUPPORTED
+/* Write the tRNS chunk */
+void /* PRIVATE */
+png_write_tRNS(png_structp png_ptr, png_bytep trans_alpha, png_color_16p tran,
+   int num_trans, int color_type)
+{
+   PNG_tRNS;
+   png_byte buf[6];
+
+   png_debug(1, "in png_write_tRNS");
+
+   if (color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
+      {
+         png_warning(png_ptr, "Invalid number of transparent colors specified");
+         return;
+      }
+      /* Write the chunk out as it is */
+      png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans_alpha,
+        (png_size_t)num_trans);
+   }
+   else if (color_type == PNG_COLOR_TYPE_GRAY)
+   {
+      /* One 16 bit value */
+      if (tran->gray >= (1 << png_ptr->bit_depth))
+      {
+         png_warning(png_ptr,
+           "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
+         return;
+      }
+      png_save_uint_16(buf, tran->gray);
+      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);
+   }
+   else if (color_type == PNG_COLOR_TYPE_RGB)
+   {
+      /* Three 16 bit values */
+      png_save_uint_16(buf, tran->red);
+      png_save_uint_16(buf + 2, tran->green);
+      png_save_uint_16(buf + 4, tran->blue);
+      if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
+      {
+         png_warning(png_ptr,
+           "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
+         return;
+      }
+      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);
+   }
+   else
+   {
+      png_warning(png_ptr, "Can't write tRNS with an alpha channel");
+   }
+}
+#endif
+
+#ifdef PNG_WRITE_bKGD_SUPPORTED
+/* Write the background chunk */
+void /* PRIVATE */
+png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
+{
+   PNG_bKGD;
+   png_byte buf[6];
+
+   png_debug(1, "in png_write_bKGD");
+
+   if (color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+          (png_ptr->num_palette ||
+          (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
+#endif
+         back->index >= png_ptr->num_palette)
+      {
+         png_warning(png_ptr, "Invalid background palette index");
+         return;
+      }
+      buf[0] = back->index;
+      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);
+   }
+   else if (color_type & PNG_COLOR_MASK_COLOR)
+   {
+      png_save_uint_16(buf, back->red);
+      png_save_uint_16(buf + 2, back->green);
+      png_save_uint_16(buf + 4, back->blue);
+      if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
+      {
+         png_warning(png_ptr,
+           "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
+         return;
+      }
+      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);
+   }
+   else
+   {
+      if (back->gray >= (1 << png_ptr->bit_depth))
+      {
+         png_warning(png_ptr,
+           "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
+         return;
+      }
+      png_save_uint_16(buf, back->gray);
+      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);
+   }
+}
+#endif
+
+#ifdef PNG_WRITE_hIST_SUPPORTED
+/* Write the histogram */
+void /* PRIVATE */
+png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
+{
+   PNG_hIST;
+   int i;
+   png_byte buf[3];
+
+   png_debug(1, "in png_write_hIST");
+
+   if (num_hist > (int)png_ptr->num_palette)
+   {
+      png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,
+         png_ptr->num_palette);
+      png_warning(png_ptr, "Invalid number of histogram entries specified");
+      return;
+   }
+
+   png_write_chunk_start(png_ptr, (png_bytep)png_hIST,
+     (png_uint_32)(num_hist * 2));
+   for (i = 0; i < num_hist; i++)
+   {
+      png_save_uint_16(buf, hist[i]);
+      png_write_chunk_data(png_ptr, buf, (png_size_t)2);
+   }
+   png_write_chunk_end(png_ptr);
+}
+#endif
+
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
+    defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
+ * and if invalid, correct the keyword rather than discarding the entire
+ * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in
+ * length, forbids leading or trailing whitespace, multiple internal spaces,
+ * and the non-break space (0x80) from ISO 8859-1.  Returns keyword length.
+ *
+ * The new_key is allocated to hold the corrected keyword and must be freed
+ * by the calling routine.  This avoids problems with trying to write to
+ * static keywords without having to have duplicate copies of the strings.
+ */
+png_size_t /* PRIVATE */
+png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
+{
+   png_size_t key_len;
+   png_charp kp, dp;
+   int kflag;
+   int kwarn=0;
+
+   png_debug(1, "in png_check_keyword");
+
+   *new_key = NULL;
+
+   if (key == NULL || (key_len = png_strlen(key)) == 0)
+   {
+      png_warning(png_ptr, "zero length keyword");
+      return ((png_size_t)0);
+   }
+
+   png_debug1(2, "Keyword to be checked is '%s'", key);
+
+   *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));
+   if (*new_key == NULL)
+   {
+      png_warning(png_ptr, "Out of memory while procesing keyword");
+      return ((png_size_t)0);
+   }
+
+   /* Replace non-printing characters with a blank and print a warning */
+   for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)
+   {
+      if ((png_byte)*kp < 0x20 ||
+         ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1))
+      {
+#ifdef PNG_STDIO_SUPPORTED
+         char msg[40];
+
+         png_snprintf(msg, 40,
+           "invalid keyword character 0x%02X", (png_byte)*kp);
+         png_warning(png_ptr, msg);
+#else
+         png_warning(png_ptr, "invalid character in keyword");
+#endif
+         *dp = ' ';
+      }
+      else
+      {
+         *dp = *kp;
+      }
+   }
+   *dp = '\0';
+
+   /* Remove any trailing white space. */
+   kp = *new_key + key_len - 1;
+   if (*kp == ' ')
+   {
+      png_warning(png_ptr, "trailing spaces removed from keyword");
+
+      while (*kp == ' ')
+      {
+         *(kp--) = '\0';
+         key_len--;
+      }
+   }
+
+   /* Remove any leading white space. */
+   kp = *new_key;
+   if (*kp == ' ')
+   {
+      png_warning(png_ptr, "leading spaces removed from keyword");
+
+      while (*kp == ' ')
+      {
+         kp++;
+         key_len--;
+      }
+   }
+
+   png_debug1(2, "Checking for multiple internal spaces in '%s'", kp);
+
+   /* Remove multiple internal spaces. */
+   for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)
+   {
+      if (*kp == ' ' && kflag == 0)
+      {
+         *(dp++) = *kp;
+         kflag = 1;
+      }
+      else if (*kp == ' ')
+      {
+         key_len--;
+         kwarn=1;
+      }
+      else
+      {
+         *(dp++) = *kp;
+         kflag = 0;
+      }
+   }
+   *dp = '\0';
+   if (kwarn)
+      png_warning(png_ptr, "extra interior spaces removed from keyword");
+
+   if (key_len == 0)
+   {
+      png_free(png_ptr, *new_key);
+      png_warning(png_ptr, "Zero length keyword");
+   }
+
+   if (key_len > 79)
+   {
+      png_warning(png_ptr, "keyword length must be 1 - 79 characters");
+      (*new_key)[79] = '\0';
+      key_len = 79;
+   }
+
+   return (key_len);
+}
+#endif
+
+#ifdef PNG_WRITE_tEXt_SUPPORTED
+/* Write a tEXt chunk */
+void /* PRIVATE */
+png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
+   png_size_t text_len)
+{
+   PNG_tEXt;
+   png_size_t key_len;
+   png_charp new_key;
+
+   png_debug(1, "in png_write_tEXt");
+
+   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)
+      return;
+
+   if (text == NULL || *text == '\0')
+      text_len = 0;
+   else
+      text_len = png_strlen(text);
+
+   /* Make sure we include the 0 after the key */
+   png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,
+      (png_uint_32)(key_len + text_len + 1));
+   /*
+    * 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
+    * 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.
+    */
+   png_write_chunk_data(png_ptr, (png_bytep)new_key,
+     (png_size_t)(key_len + 1));
+   if (text_len)
+      png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);
+
+   png_write_chunk_end(png_ptr);
+   png_free(png_ptr, new_key);
+}
+#endif
+
+#ifdef PNG_WRITE_zTXt_SUPPORTED
+/* Write a compressed text chunk */
+void /* PRIVATE */
+png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
+   png_size_t text_len, int compression)
+{
+   PNG_zTXt;
+   png_size_t key_len;
+   char buf[1];
+   png_charp new_key;
+   compression_state comp;
+
+   png_debug(1, "in png_write_zTXt");
+
+   comp.num_output_ptr = 0;
+   comp.max_output_ptr = 0;
+   comp.output_ptr = NULL;
+   comp.input = NULL;
+   comp.input_len = 0;
+
+   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)
+   {
+      png_free(png_ptr, new_key);
+      return;
+   }
+
+   if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)
+   {
+      png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);
+      png_free(png_ptr, new_key);
+      return;
+   }
+
+   text_len = png_strlen(text);
+
+   /* Compute the compressed data; do it now for the length */
+   text_len = png_text_compress(png_ptr, text, text_len, compression,
+       &comp);
+
+   /* Write start of chunk */
+   png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,
+     (png_uint_32)(key_len+text_len + 2));
+   /* Write key */
+   png_write_chunk_data(png_ptr, (png_bytep)new_key,
+     (png_size_t)(key_len + 1));
+   png_free(png_ptr, new_key);
+
+   buf[0] = (png_byte)compression;
+   /* Write compression */
+   png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);
+   /* Write the compressed data */
+   png_write_compressed_data_out(png_ptr, &comp);
+
+   /* Close the chunk */
+   png_write_chunk_end(png_ptr);
+}
+#endif
+
+#ifdef PNG_WRITE_iTXt_SUPPORTED
+/* Write an iTXt chunk */
+void /* PRIVATE */
+png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
+    png_charp lang, png_charp lang_key, png_charp text)
+{
+   PNG_iTXt;
+   png_size_t lang_len, key_len, lang_key_len, text_len;
+   png_charp new_lang;
+   png_charp new_key = NULL;
+   png_byte cbuf[2];
+   compression_state comp;
+
+   png_debug(1, "in png_write_iTXt");
+
+   comp.num_output_ptr = 0;
+   comp.max_output_ptr = 0;
+   comp.output_ptr = NULL;
+   comp.input = NULL;
+
+   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)
+      return;
+
+   if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)
+   {
+      png_warning(png_ptr, "Empty language field in iTXt chunk");
+      new_lang = NULL;
+      lang_len = 0;
+   }
+
+   if (lang_key == NULL)
+      lang_key_len = 0;
+   else
+      lang_key_len = png_strlen(lang_key);
+
+   if (text == NULL)
+      text_len = 0;
+   else
+      text_len = png_strlen(text);
+
+   /* Compute the compressed data; do it now for the length */
+   text_len = png_text_compress(png_ptr, text, text_len, compression-2,
+      &comp);
+
+
+   /* Make sure we include the compression flag, the compression byte,
+    * and the NULs after the key, lang, and lang_key parts */
+
+   png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,
+          (png_uint_32)(
+        5 /* comp byte, comp flag, terminators for key, lang and lang_key */
+        + key_len
+        + lang_len
+        + lang_key_len
+        + text_len));
+
+   /* 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
+    * 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.
+    */
+   png_write_chunk_data(png_ptr, (png_bytep)new_key,
+     (png_size_t)(key_len + 1));
+
+   /* Set the compression flag */
+   if (compression == PNG_ITXT_COMPRESSION_NONE || \
+       compression == PNG_TEXT_COMPRESSION_NONE)
+       cbuf[0] = 0;
+   else /* compression == PNG_ITXT_COMPRESSION_zTXt */
+       cbuf[0] = 1;
+   /* Set the compression method */
+   cbuf[1] = 0;
+   png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);
+
+   cbuf[0] = 0;
+   png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),
+     (png_size_t)(lang_len + 1));
+   png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),
+     (png_size_t)(lang_key_len + 1));
+   png_write_compressed_data_out(png_ptr, &comp);
+
+   png_write_chunk_end(png_ptr);
+   png_free(png_ptr, new_key);
+   png_free(png_ptr, new_lang);
+}
+#endif
+
+#ifdef PNG_WRITE_oFFs_SUPPORTED
+/* Write the oFFs chunk */
+void /* PRIVATE */
+png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
+   int unit_type)
+{
+   PNG_oFFs;
+   png_byte buf[9];
+
+   png_debug(1, "in png_write_oFFs");
+
+   if (unit_type >= PNG_OFFSET_LAST)
+      png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
+
+   png_save_int_32(buf, x_offset);
+   png_save_int_32(buf + 4, y_offset);
+   buf[8] = (png_byte)unit_type;
+
+   png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);
+}
+#endif
+#ifdef PNG_WRITE_pCAL_SUPPORTED
+/* Write the pCAL chunk (described in the PNG extensions document) */
+void /* PRIVATE */
+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_pCAL;
+   png_size_t purpose_len, units_len, total_len;
+   png_uint_32p params_len;
+   png_byte buf[10];
+   png_charp new_purpose;
+   int i;
+
+   png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
+
+   if (type >= PNG_EQUATION_LAST)
+      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
+
+   purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;
+   png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
+   units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);
+   png_debug1(3, "pCAL units length = %d", (int)units_len);
+   total_len = purpose_len + units_len + 10;
+
+   params_len = (png_uint_32p)png_malloc(png_ptr,
+      (png_alloc_size_t)(nparams * png_sizeof(png_uint_32)));
+
+   /* Find the length of each parameter, making sure we don't count the
+      null terminator for the last parameter. */
+   for (i = 0; i < nparams; i++)
+   {
+      params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
+      png_debug2(3, "pCAL parameter %d length = %lu", i,
+        (unsigned long) params_len[i]);
+      total_len += (png_size_t)params_len[i];
+   }
+
+   png_debug1(3, "pCAL total length = %d", (int)total_len);
+   png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);
+   png_write_chunk_data(png_ptr, (png_bytep)new_purpose,
+     (png_size_t)purpose_len);
+   png_save_int_32(buf, X0);
+   png_save_int_32(buf + 4, X1);
+   buf[8] = (png_byte)type;
+   buf[9] = (png_byte)nparams;
+   png_write_chunk_data(png_ptr, buf, (png_size_t)10);
+   png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);
+
+   png_free(png_ptr, new_purpose);
+
+   for (i = 0; i < nparams; i++)
+   {
+      png_write_chunk_data(png_ptr, (png_bytep)params[i],
+         (png_size_t)params_len[i]);
+   }
+
+   png_free(png_ptr, params_len);
+   png_write_chunk_end(png_ptr);
+}
+#endif
+
+#ifdef PNG_WRITE_sCAL_SUPPORTED
+/* Write the sCAL chunk */
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
+void /* PRIVATE */
+png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
+{
+   PNG_sCAL;
+   char buf[64];
+   png_size_t total_len;
+
+   png_debug(1, "in png_write_sCAL");
+
+   buf[0] = (char)unit;
+   png_snprintf(buf + 1, 63, "%12.12e", width);
+   total_len = 1 + png_strlen(buf + 1) + 1;
+   png_snprintf(buf + total_len, 64-total_len, "%12.12e", height);
+   total_len += png_strlen(buf + total_len);
+
+   png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
+   png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);
+}
+#else
+#ifdef PNG_FIXED_POINT_SUPPORTED
+void /* PRIVATE */
+png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
+   png_charp height)
+{
+   PNG_sCAL;
+   png_byte buf[64];
+   png_size_t wlen, hlen, total_len;
+
+   png_debug(1, "in png_write_sCAL_s");
+
+   wlen = png_strlen(width);
+   hlen = png_strlen(height);
+   total_len = wlen + hlen + 2;
+   if (total_len > 64)
+   {
+      png_warning(png_ptr, "Can't write sCAL (buffer too small)");
+      return;
+   }
+
+   buf[0] = (png_byte)unit;
+   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_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
+   png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);
+}
+#endif
+#endif
+#endif
+
+#ifdef PNG_WRITE_pHYs_SUPPORTED
+/* Write the pHYs chunk */
+void /* PRIVATE */
+png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
+   png_uint_32 y_pixels_per_unit,
+   int unit_type)
+{
+   PNG_pHYs;
+   png_byte buf[9];
+
+   png_debug(1, "in png_write_pHYs");
+
+   if (unit_type >= PNG_RESOLUTION_LAST)
+      png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
+
+   png_save_uint_32(buf, x_pixels_per_unit);
+   png_save_uint_32(buf + 4, y_pixels_per_unit);
+   buf[8] = (png_byte)unit_type;
+
+   png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);
+}
+#endif
+
+#ifdef PNG_WRITE_tIME_SUPPORTED
+/* Write the tIME chunk.  Use either png_convert_from_struct_tm()
+ * or png_convert_from_time_t(), or fill in the structure yourself.
+ */
+void /* PRIVATE */
+png_write_tIME(png_structp png_ptr, png_timep mod_time)
+{
+   PNG_tIME;
+   png_byte buf[7];
+
+   png_debug(1, "in png_write_tIME");
+
+   if (mod_time->month  > 12 || mod_time->month  < 1 ||
+       mod_time->day    > 31 || mod_time->day    < 1 ||
+       mod_time->hour   > 23 || mod_time->second > 60)
+   {
+      png_warning(png_ptr, "Invalid time specified for tIME chunk");
+      return;
+   }
+
+   png_save_uint_16(buf, mod_time->year);
+   buf[2] = mod_time->month;
+   buf[3] = mod_time->day;
+   buf[4] = mod_time->hour;
+   buf[5] = mod_time->minute;
+   buf[6] = mod_time->second;
+
+   png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);
+}
+#endif
+
+/* Initializes the row writing capability of libpng */
+void /* PRIVATE */
+png_write_start_row(png_structp png_ptr)
+{
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+   /* Start of interlace block in the y direction */
+   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+   /* Offset to next interlace block in the y direction */
+   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif
+
+   png_size_t buf_size;
+
+   png_debug(1, "in png_write_start_row");
+
+   buf_size = (png_size_t)(PNG_ROWBYTES(
+      png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
+
+   /* Set up row buffer */
+   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,
+     (png_alloc_size_t)buf_size);
+   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
+
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   /* Set up filtering buffer, if using this filter */
+   if (png_ptr->do_filter & PNG_FILTER_SUB)
+   {
+      png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
+         (png_alloc_size_t)(png_ptr->rowbytes + 1));
+      png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
+   }
+
+   /* 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))
+   {
+      /* Set up previous row buffer */
+      png_ptr->prev_row = (png_bytep)png_calloc(png_ptr,
+         (png_alloc_size_t)buf_size);
+
+      if (png_ptr->do_filter & PNG_FILTER_UP)
+      {
+         png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
+            (png_size_t)(png_ptr->rowbytes + 1));
+         png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
+      }
+
+      if (png_ptr->do_filter & PNG_FILTER_AVG)
+      {
+         png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
+            (png_alloc_size_t)(png_ptr->rowbytes + 1));
+         png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
+      }
+
+      if (png_ptr->do_filter & PNG_FILTER_PAETH)
+      {
+         png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
+            (png_size_t)(png_ptr->rowbytes + 1));
+         png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
+      }
+   }
+#endif /* PNG_WRITE_FILTER_SUPPORTED */
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* If interlaced, we need to set up width and height of pass */
+   if (png_ptr->interlaced)
+   {
+      if (!(png_ptr->transformations & PNG_INTERLACE))
+      {
+         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
+            png_pass_ystart[0]) / png_pass_yinc[0];
+         png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
+            png_pass_start[0]) / png_pass_inc[0];
+      }
+      else
+      {
+         png_ptr->num_rows = png_ptr->height;
+         png_ptr->usr_width = png_ptr->width;
+      }
+   }
+   else
+#endif
+   {
+      png_ptr->num_rows = png_ptr->height;
+      png_ptr->usr_width = png_ptr->width;
+   }
+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+   png_ptr->zstream.next_out = png_ptr->zbuf;
+}
+
+/* Internal use only.  Called when finished processing a row of data. */
+void /* PRIVATE */
+png_write_finish_row(png_structp png_ptr)
+{
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+   /* Start of interlace block in the y direction */
+   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+   /* Offset to next interlace block in the y direction */
+   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif
+
+   int ret;
+
+   png_debug(1, "in png_write_finish_row");
+
+   /* Next row */
+   png_ptr->row_number++;
+
+   /* See if we are done */
+   if (png_ptr->row_number < png_ptr->num_rows)
+      return;
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* If interlaced, go to next pass */
+   if (png_ptr->interlaced)
+   {
+      png_ptr->row_number = 0;
+      if (png_ptr->transformations & PNG_INTERLACE)
+      {
+         png_ptr->pass++;
+      }
+      else
+      {
+         /* Loop until we find a non-zero width or height pass */
+         do
+         {
+            png_ptr->pass++;
+            if (png_ptr->pass >= 7)
+               break;
+            png_ptr->usr_width = (png_ptr->width +
+               png_pass_inc[png_ptr->pass] - 1 -
+               png_pass_start[png_ptr->pass]) /
+               png_pass_inc[png_ptr->pass];
+            png_ptr->num_rows = (png_ptr->height +
+               png_pass_yinc[png_ptr->pass] - 1 -
+               png_pass_ystart[png_ptr->pass]) /
+               png_pass_yinc[png_ptr->pass];
+            if (png_ptr->transformations & PNG_INTERLACE)
+               break;
+         } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
+
+      }
+
+      /* Reset the row above the image for the next pass */
+      if (png_ptr->pass < 7)
+      {
+         if (png_ptr->prev_row != NULL)
+            png_memset(png_ptr->prev_row, 0,
+               (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
+               png_ptr->usr_bit_depth, png_ptr->width)) + 1);
+         return;
+      }
+   }
+#endif
+
+   /* If we get here, we've just written the last row, so we need
+      to flush the compressor */
+   do
+   {
+      /* Tell the compressor we are done */
+      ret = deflate(&png_ptr->zstream, Z_FINISH);
+      /* Check for an error */
+      if (ret == Z_OK)
+      {
+         /* Check to see if we need more room */
+         if (!(png_ptr->zstream.avail_out))
+         {
+            png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+            png_ptr->zstream.next_out = png_ptr->zbuf;
+            png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+         }
+      }
+      else if (ret != Z_STREAM_END)
+      {
+         if (png_ptr->zstream.msg != NULL)
+            png_error(png_ptr, png_ptr->zstream.msg);
+         else
+            png_error(png_ptr, "zlib error");
+      }
+   } while (ret != Z_STREAM_END);
+
+   /* Write any extra space */
+   if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
+   {
+      png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -
+         png_ptr->zstream.avail_out);
+   }
+
+   deflateReset(&png_ptr->zstream);
+   png_ptr->zstream.data_type = Z_BINARY;
+}
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+/* Pick out the correct pixels for the interlace pass.
+ * The basic idea here is to go through the row with a source
+ * pointer and a destination pointer (sp and dp), and copy the
+ * correct pixels for the pass.  As the row gets compacted,
+ * sp will always be >= dp, so we should never overwrite anything.
+ * See the default: case for the easiest code to understand.
+ */
+void /* PRIVATE */
+png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
+{
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+   png_debug(1, "in png_do_write_interlace");
+
+   /* We don't have to do anything on the last pass (6) */
+   if (pass < 6)
+   {
+      /* Each pixel depth is handled separately */
+      switch (row_info->pixel_depth)
+      {
+         case 1:
+         {
+            png_bytep sp;
+            png_bytep dp;
+            int shift;
+            int d;
+            int value;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            dp = row;
+            d = 0;
+            shift = 7;
+            for (i = png_pass_start[pass]; i < row_width;
+               i += png_pass_inc[pass])
+            {
+               sp = row + (png_size_t)(i >> 3);
+               value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
+               d |= (value << shift);
+
+               if (shift == 0)
+               {
+                  shift = 7;
+                  *dp++ = (png_byte)d;
+                  d = 0;
+               }
+               else
+                  shift--;
+
+            }
+            if (shift != 7)
+               *dp = (png_byte)d;
+            break;
+         }
+         case 2:
+         {
+            png_bytep sp;
+            png_bytep dp;
+            int shift;
+            int d;
+            int value;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            dp = row;
+            shift = 6;
+            d = 0;
+            for (i = png_pass_start[pass]; i < row_width;
+               i += png_pass_inc[pass])
+            {
+               sp = row + (png_size_t)(i >> 2);
+               value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
+               d |= (value << shift);
+
+               if (shift == 0)
+               {
+                  shift = 6;
+                  *dp++ = (png_byte)d;
+                  d = 0;
+               }
+               else
+                  shift -= 2;
+            }
+            if (shift != 6)
+                   *dp = (png_byte)d;
+            break;
+         }
+         case 4:
+         {
+            png_bytep sp;
+            png_bytep dp;
+            int shift;
+            int d;
+            int value;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+
+            dp = row;
+            shift = 4;
+            d = 0;
+            for (i = png_pass_start[pass]; i < row_width;
+               i += png_pass_inc[pass])
+            {
+               sp = row + (png_size_t)(i >> 1);
+               value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
+               d |= (value << shift);
+
+               if (shift == 0)
+               {
+                  shift = 4;
+                  *dp++ = (png_byte)d;
+                  d = 0;
+               }
+               else
+                  shift -= 4;
+            }
+            if (shift != 4)
+               *dp = (png_byte)d;
+            break;
+         }
+         default:
+         {
+            png_bytep sp;
+            png_bytep dp;
+            png_uint_32 i;
+            png_uint_32 row_width = row_info->width;
+            png_size_t pixel_bytes;
+
+            /* Start at the beginning */
+            dp = row;
+            /* Find out how many bytes each pixel takes up */
+            pixel_bytes = (row_info->pixel_depth >> 3);
+            /* Loop through the row, only looking at the pixels that
+               matter */
+            for (i = png_pass_start[pass]; i < row_width;
+               i += png_pass_inc[pass])
+            {
+               /* Find out where the original pixel is */
+               sp = row + (png_size_t)i * pixel_bytes;
+               /* Move the pixel */
+               if (dp != sp)
+                  png_memcpy(dp, sp, pixel_bytes);
+               /* Next pixel */
+               dp += pixel_bytes;
+            }
+            break;
+         }
+      }
+      /* Set new row width */
+      row_info->width = (row_info->width +
+         png_pass_inc[pass] - 1 -
+         png_pass_start[pass]) /
+         png_pass_inc[pass];
+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
+            row_info->width);
+   }
+}
+#endif
+
+/* This filters the row, chooses which filter to use, if it has not already
+ * been specified by the application, and then writes the row out with the
+ * chosen filter.
+ */
+#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)
+#define PNG_HISHIFT 10
+#define PNG_LOMASK ((png_uint_32)0xffffL)
+#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
+void /* PRIVATE */
+png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
+{
+   png_bytep best_row;
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   png_bytep prev_row, row_buf;
+   png_uint_32 mins, bpp;
+   png_byte filter_to_do = png_ptr->do_filter;
+   png_uint_32 row_bytes = row_info->rowbytes;
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+   int num_p_filters = (int)png_ptr->num_prev_filters;
+#endif 
+
+   png_debug(1, "in png_write_find_filter");
+
+#ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+  if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)
+  {
+      /* These will never be selected so we need not test them. */
+      filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH);
+  }
+#endif 
+
+   /* Find out how many bytes offset each pixel is */
+   bpp = (row_info->pixel_depth + 7) >> 3;
+
+   prev_row = png_ptr->prev_row;
+#endif
+   best_row = png_ptr->row_buf;
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   row_buf = best_row;
+   mins = PNG_MAXSUM;
+
+   /* The prediction method we use is to find which method provides the
+    * smallest value when summing the absolute values of the distances
+    * from zero, using anything >= 128 as negative numbers.  This is known
+    * as the "minimum sum of absolute differences" heuristic.  Other
+    * heuristics are the "weighted minimum sum of absolute differences"
+    * (experimental and can in theory improve compression), and the "zlib
+    * predictive" method (not implemented yet), which does test compressions
+    * of lines using different filter methods, and then chooses the
+    * (series of) filter(s) that give minimum compressed data size (VERY
+    * computationally expensive).
+    *
+    * GRR 980525:  consider also
+    *   (1) minimum sum of absolute differences from running average (i.e.,
+    *       keep running sum of non-absolute differences & count of bytes)
+    *       [track dispersion, too?  restart average if dispersion too large?]
+    *  (1b) minimum sum of absolute differences from sliding average, probably
+    *       with window size <= deflate window (usually 32K)
+    *   (2) minimum sum of squared differences from zero or running average
+    *       (i.e., ~ root-mean-square approach)
+    */
+
+
+   /* We don't need to test the 'no filter' case if this is the only filter
+    * that has been chosen, as it doesn't actually do anything to the data.
+    */
+   if ((filter_to_do & PNG_FILTER_NONE) &&
+       filter_to_do != PNG_FILTER_NONE)
+   {
+      png_bytep rp;
+      png_uint_32 sum = 0;
+      png_uint_32 i;
+      int v;
+
+      for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
+      {
+         v = *rp;
+         sum += (v < 128) ? v : 256 - v;
+      }
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         png_uint_32 sumhi, sumlo;
+         int j;
+         sumlo = sum & PNG_LOMASK;
+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
+
+         /* Reduce the sum if we match any of the previous rows */
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
+            {
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         /* Factor in the cost of this filter (this is here for completeness,
+          * but it makes no sense to have a "cost" for the NONE filter, as
+          * it has the minimum possible computational cost - none).
+          */
+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
+            PNG_COST_SHIFT;
+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
+            PNG_COST_SHIFT;
+
+         if (sumhi > PNG_HIMASK)
+            sum = PNG_MAXSUM;
+         else
+            sum = (sumhi << PNG_HISHIFT) + sumlo;
+      }
+#endif
+      mins = sum;
+   }
+
+   /* Sub filter */
+   if (filter_to_do == PNG_FILTER_SUB)
+   /* It's the only filter so no testing is needed */
+   {
+      png_bytep rp, lp, dp;
+      png_uint_32 i;
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
+           i++, rp++, dp++)
+      {
+         *dp = *rp;
+      }
+      for (lp = row_buf + 1; i < row_bytes;
+         i++, rp++, lp++, dp++)
+      {
+         *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
+      }
+      best_row = png_ptr->sub_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_SUB)
+   {
+      png_bytep rp, dp, lp;
+      png_uint_32 sum = 0, lmins = mins;
+      png_uint_32 i;
+      int v;
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      /* We temporarily increase the "minimum sum" by the factor we
+       * would reduce the sum of this filter, so that we can do the
+       * early exit comparison without scaling the sum each time.
+       */
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 lmhi, lmlo;
+         lmlo = lmins & PNG_LOMASK;
+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
+            {
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+            PNG_COST_SHIFT;
+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+            PNG_COST_SHIFT;
+
+         if (lmhi > PNG_HIMASK)
+            lmins = PNG_MAXSUM;
+         else
+            lmins = (lmhi << PNG_HISHIFT) + lmlo;
+      }
+#endif
+
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
+           i++, rp++, dp++)
+      {
+         v = *dp = *rp;
+
+         sum += (v < 128) ? v : 256 - v;
+      }
+      for (lp = row_buf + 1; i < row_bytes;
+         i++, rp++, lp++, dp++)
+      {
+         v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
+
+         sum += (v < 128) ? v : 256 - v;
+
+         if (sum > lmins)  /* We are already worse, don't continue. */
+            break;
+      }
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 sumhi, sumlo;
+         sumlo = sum & PNG_LOMASK;
+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
+            {
+               sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+            PNG_COST_SHIFT;
+         sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
+            PNG_COST_SHIFT;
+
+         if (sumhi > PNG_HIMASK)
+            sum = PNG_MAXSUM;
+         else
+            sum = (sumhi << PNG_HISHIFT) + sumlo;
+      }
+#endif
+
+      if (sum < mins)
+      {
+         mins = sum;
+         best_row = png_ptr->sub_row;
+      }
+   }
+
+   /* Up filter */
+   if (filter_to_do == PNG_FILTER_UP)
+   {
+      png_bytep rp, dp, pp;
+      png_uint_32 i;
+
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
+           pp = prev_row + 1; i < row_bytes;
+           i++, rp++, pp++, dp++)
+      {
+         *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
+      }
+      best_row = png_ptr->up_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_UP)
+   {
+      png_bytep rp, dp, pp;
+      png_uint_32 sum = 0, lmins = mins;
+      png_uint_32 i;
+      int v;
+
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 lmhi, lmlo;
+         lmlo = lmins & PNG_LOMASK;
+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
+            {
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
+            PNG_COST_SHIFT;
+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
+            PNG_COST_SHIFT;
+
+         if (lmhi > PNG_HIMASK)
+            lmins = PNG_MAXSUM;
+         else
+            lmins = (lmhi << PNG_HISHIFT) + lmlo;
+      }
+#endif
+
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
+           pp = prev_row + 1; i < row_bytes; i++)
+      {
+         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
+
+         sum += (v < 128) ? v : 256 - v;
+
+         if (sum > lmins)  /* We are already worse, don't continue. */
+            break;
+      }
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 sumhi, sumlo;
+         sumlo = sum & PNG_LOMASK;
+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
+            {
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
+            PNG_COST_SHIFT;
+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
+            PNG_COST_SHIFT;
+
+         if (sumhi > PNG_HIMASK)
+            sum = PNG_MAXSUM;
+         else
+            sum = (sumhi << PNG_HISHIFT) + sumlo;
+      }
+#endif
+
+      if (sum < mins)
+      {
+         mins = sum;
+         best_row = png_ptr->up_row;
+      }
+   }
+
+   /* Avg filter */
+   if (filter_to_do == PNG_FILTER_AVG)
+   {
+      png_bytep rp, dp, pp, lp;
+      png_uint_32 i;
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
+           pp = prev_row + 1; i < bpp; i++)
+      {
+         *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
+      }
+      for (lp = row_buf + 1; i < row_bytes; i++)
+      {
+         *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
+                 & 0xff);
+      }
+      best_row = png_ptr->avg_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_AVG)
+   {
+      png_bytep rp, dp, pp, lp;
+      png_uint_32 sum = 0, lmins = mins;
+      png_uint_32 i;
+      int v;
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 lmhi, lmlo;
+         lmlo = lmins & PNG_LOMASK;
+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
+            {
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
+            PNG_COST_SHIFT;
+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
+            PNG_COST_SHIFT;
+
+         if (lmhi > PNG_HIMASK)
+            lmins = PNG_MAXSUM;
+         else
+            lmins = (lmhi << PNG_HISHIFT) + lmlo;
+      }
+#endif
+
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
+           pp = prev_row + 1; i < bpp; i++)
+      {
+         v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
+
+         sum += (v < 128) ? v : 256 - v;
+      }
+      for (lp = row_buf + 1; i < row_bytes; i++)
+      {
+         v = *dp++ =
+          (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
+
+         sum += (v < 128) ? v : 256 - v;
+
+         if (sum > lmins)  /* We are already worse, don't continue. */
+            break;
+      }
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 sumhi, sumlo;
+         sumlo = sum & PNG_LOMASK;
+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
+            {
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
+            PNG_COST_SHIFT;
+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
+            PNG_COST_SHIFT;
+
+         if (sumhi > PNG_HIMASK)
+            sum = PNG_MAXSUM;
+         else
+            sum = (sumhi << PNG_HISHIFT) + sumlo;
+      }
+#endif
+
+      if (sum < mins)
+      {
+         mins = sum;
+         best_row = png_ptr->avg_row;
+      }
+   }
+
+   /* Paeth filter */
+   if (filter_to_do == PNG_FILTER_PAETH)
+   {
+      png_bytep rp, dp, pp, cp, lp;
+      png_uint_32 i;
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
+           pp = prev_row + 1; i < bpp; i++)
+      {
+         *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
+      }
+
+      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
+      {
+         int a, b, c, pa, pb, pc, p;
+
+         b = *pp++;
+         c = *cp++;
+         a = *lp++;
+
+         p = b - c;
+         pc = a - c;
+
+#ifdef PNG_USE_ABS
+         pa = abs(p);
+         pb = abs(pc);
+         pc = abs(p + pc);
+#else
+         pa = p < 0 ? -p : p;
+         pb = pc < 0 ? -pc : pc;
+         pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+
+         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+
+         *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
+      }
+      best_row = png_ptr->paeth_row;
+   }
+
+   else if (filter_to_do & PNG_FILTER_PAETH)
+   {
+      png_bytep rp, dp, pp, cp, lp;
+      png_uint_32 sum = 0, lmins = mins;
+      png_uint_32 i;
+      int v;
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 lmhi, lmlo;
+         lmlo = lmins & PNG_LOMASK;
+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
+            {
+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+            PNG_COST_SHIFT;
+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+            PNG_COST_SHIFT;
+
+         if (lmhi > PNG_HIMASK)
+            lmins = PNG_MAXSUM;
+         else
+            lmins = (lmhi << PNG_HISHIFT) + lmlo;
+      }
+#endif
+
+      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
+           pp = prev_row + 1; i < bpp; i++)
+      {
+         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
+
+         sum += (v < 128) ? v : 256 - v;
+      }
+
+      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
+      {
+         int a, b, c, pa, pb, pc, p;
+
+         b = *pp++;
+         c = *cp++;
+         a = *lp++;
+
+#ifndef PNG_SLOW_PAETH
+         p = b - c;
+         pc = a - c;
+#ifdef PNG_USE_ABS
+         pa = abs(p);
+         pb = abs(pc);
+         pc = abs(p + pc);
+#else
+         pa = p < 0 ? -p : p;
+         pb = pc < 0 ? -pc : pc;
+         pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+#else /* PNG_SLOW_PAETH */
+         p = a + b - c;
+         pa = abs(p - a);
+         pb = abs(p - b);
+         pc = abs(p - c);
+         if (pa <= pb && pa <= pc)
+            p = a;
+         else if (pb <= pc)
+            p = b;
+         else
+            p = c;
+#endif /* PNG_SLOW_PAETH */
+
+         v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
+
+         sum += (v < 128) ? v : 256 - v;
+
+         if (sum > lmins)  /* We are already worse, don't continue. */
+            break;
+      }
+
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
+      {
+         int j;
+         png_uint_32 sumhi, sumlo;
+         sumlo = sum & PNG_LOMASK;
+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
+
+         for (j = 0; j < num_p_filters; j++)
+         {
+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
+            {
+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>
+                  PNG_WEIGHT_SHIFT;
+            }
+         }
+
+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+            PNG_COST_SHIFT;
+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
+            PNG_COST_SHIFT;
+
+         if (sumhi > PNG_HIMASK)
+            sum = PNG_MAXSUM;
+         else
+            sum = (sumhi << PNG_HISHIFT) + sumlo;
+      }
+#endif
+
+      if (sum < mins)
+      {
+         best_row = png_ptr->paeth_row;
+      }
+   }
+#endif /* PNG_WRITE_FILTER_SUPPORTED */
+   /* Do the actual writing of the filtered row data from the chosen filter. */
+
+   png_write_filtered_row(png_ptr, best_row);
+
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+   /* Save the type of filter we picked this time for future calculations */
+   if (png_ptr->num_prev_filters > 0)
+   {
+      int j;
+      for (j = 1; j < num_p_filters; j++)
+      {
+         png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
+      }
+      png_ptr->prev_filters[j] = best_row[0];
+   }
+#endif
+#endif /* PNG_WRITE_FILTER_SUPPORTED */
+}
+
+
+/* Do the actual writing of a previously filtered row. */
+void /* PRIVATE */
+png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
+{
+   png_debug(1, "in png_write_filtered_row");
+
+   png_debug1(2, "filter = %d", filtered_row[0]);
+   /* Set up the zlib input buffer */
+
+   png_ptr->zstream.next_in = filtered_row;
+   png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;
+   /* Repeat until we have compressed all the data */
+   do
+   {
+      int ret; /* Return of zlib */
+
+      /* Compress the data */
+      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
+      /* Check for compression errors */
+      if (ret != Z_OK)
+      {
+         if (png_ptr->zstream.msg != NULL)
+            png_error(png_ptr, png_ptr->zstream.msg);
+         else
+            png_error(png_ptr, "zlib error");
+      }
+
+      /* See if it is time to write another IDAT */
+      if (!(png_ptr->zstream.avail_out))
+      {
+         /* Write the IDAT and reset the zlib output buffer */
+         png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+         png_ptr->zstream.next_out = png_ptr->zbuf;
+         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+      }
+   /* Repeat until all data has been compressed */
+   } while (png_ptr->zstream.avail_in);
+
+   /* Swap the current and previous rows */
+   if (png_ptr->prev_row != NULL)
+   {
+      png_bytep tptr;
+
+      tptr = png_ptr->prev_row;
+      png_ptr->prev_row = png_ptr->row_buf;
+      png_ptr->row_buf = tptr;
+   }
+
+   /* Finish row - updates counters and flushes zlib if last row */
+   png_write_finish_row(png_ptr);
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+   png_ptr->flush_rows++;
+
+   if (png_ptr->flush_dist > 0 &&
+       png_ptr->flush_rows >= png_ptr->flush_dist)
+   {
+      png_write_flush(png_ptr);
+   }
+#endif
+}
+#endif /* PNG_WRITE_SUPPORTED */