From 94553f886986e3982a539ddb0f2e224a1e48a0b7 Mon Sep 17 00:00:00 2001
From: Christopher Roy Bratusek <nano@tuxfamily.org>
Date: Sat, 8 Dec 2012 21:29:06 +0100
Subject: [PATCH] nand-loader: add error 002 fix, green-screen fix and date-bug
 fix (courtesy of wilsoff)

---
 nand-loader/lib/libpng.a              |  Bin 237236 -> 0 bytes
 nand-loader/source/libpng/png.h       | 3569 -------------------------
 nand-loader/source/libpng/pngconf.h   | 1481 ----------
 nand-loader/source/libpng/pngu/pngu.c | 1132 --------
 nand-loader/source/libpng/pngu/pngu.h |  171 --
 nand-loader/source/loader.c           |   19 +
 nand-loader/source/tools.c            |  252 ++
 nand-loader/source/tools.h            |   31 +
 8 files changed, 302 insertions(+), 6353 deletions(-)
 delete mode 100644 nand-loader/lib/libpng.a
 delete mode 100644 nand-loader/source/libpng/png.h
 delete mode 100644 nand-loader/source/libpng/pngconf.h
 delete mode 100644 nand-loader/source/libpng/pngu/pngu.c
 delete mode 100644 nand-loader/source/libpng/pngu/pngu.h
 create mode 100644 nand-loader/source/tools.c
 create mode 100644 nand-loader/source/tools.h

diff --git a/nand-loader/lib/libpng.a b/nand-loader/lib/libpng.a
deleted file mode 100644
index 67ff51fe6ec1a5d9bc28aa53563f86df386f8cec..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 237236
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

diff --git a/nand-loader/source/libpng/png.h b/nand-loader/source/libpng/png.h
deleted file mode 100644
index e0cec0c..0000000
--- a/nand-loader/source/libpng/png.h
+++ /dev/null
@@ -1,3569 +0,0 @@
-/* png.h - header file for PNG reference library
- *
- * libpng version 1.2.29 - May 8, 2008
- * Copyright (c) 1998-2008 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.)
- *
- * 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.29 - May 8, 2008: 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]
- *
- *    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.
- *
- * libpng versions 1.2.6, August 15, 2004, through 1.2.29, May 8, 2008, are
- * Copyright (c) 2004, 2006-2008 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:
- * =========================
- *
- *    May 8, 2008
- *
- *    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.29 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.29"
-#define PNG_HEADER_VERSION_STRING \
-   " libpng version 1.2.29 - May 8, 2008\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 29
-/* 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 10229 /* 1.2.29 */
-
-#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. 
- */
-
-#if defined(PNG_USER_PRIVATEBUILD)
-#  define PNG_LIBPNG_BUILD_TYPE \
-          (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)
-#else
-#  if defined(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)
-/* 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;       /* width of image in pixels (from IHDR) */
-   png_uint_32 height;      /* height of image in pixels (from IHDR) */
-   png_uint_32 valid;       /* valid chunk data (see PNG_INFO_ below) */
-   png_uint_32 rowbytes;    /* bytes needed to hold an untransformed row */
-   png_colorp palette;      /* array of color values (valid & PNG_INFO_PLTE) */
-   png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */
-   png_uint_16 num_trans;   /* number of transparent palette color (tRNS) */
-   png_byte bit_depth;      /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */
-   png_byte color_type;     /* see PNG_COLOR_TYPE_ below (from IHDR) */
-   /* The following three should have been named *_method not *_type */
-   png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */
-   png_byte filter_type;    /* must be PNG_FILTER_TYPE_BASE (from IHDR) */
-   png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
-
-   /* The following is informational only on read, and not used on writes. */
-   png_byte channels;       /* number of data channels per pixel (1, 2, 3, 4) */
-   png_byte pixel_depth;    /* number of bits per pixel */
-   png_byte spare_byte;     /* to align the data, and for future use */
-   png_byte signature[8];   /* 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; /* gamma value of image, if (valid & PNG_INFO_gAMA) */
-#endif
-
-#if defined(PNG_sRGB_SUPPORTED)
-    /* GR-P, 0.96a */
-    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */
-   png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */
-#endif
-
-#if defined(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; /* number of comments read/to write */
-   int max_text; /* current size of text array */
-   png_textp text; /* array of comments read/to write */
-#endif /* PNG_TEXT_SUPPORTED */
-
-#if defined(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;
-#endif
-
-#if defined(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; /* 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; /* transparent values for paletted image */
-   png_color_16 trans_values; /* 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;
-#endif
-
-#if defined(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; /* x offset on page */
-   png_int_32 y_offset; /* y offset on page */
-   png_byte offset_unit_type; /* offset units type */
-#endif
-
-#if defined(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; /* horizontal pixel density */
-   png_uint_32 y_pixels_per_unit; /* vertical pixel density */
-   png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */
-#endif
-
-#if defined(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;
-#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;
-   float y_white;
-   float x_red;
-   float y_red;
-   float x_green;
-   float y_green;
-   float x_blue;
-   float y_blue;
-#endif
-#endif
-
-#if defined(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;  /* pCAL chunk description string */
-   png_int_32 pcal_X0;      /* minimum value */
-   png_int_32 pcal_X1;      /* maximum value */
-   png_charp pcal_units;    /* Latin-1 string giving physical units */
-   png_charpp pcal_params;  /* ASCII strings containing parameter values */
-   png_byte pcal_type;      /* equation type (see PNG_EQUATION_ below) */
-   png_byte pcal_nparams;   /* 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;     /* flags items libpng is responsible for freeing */
-#endif
-
-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
-   /* storage for unknown chunks that the library doesn't recognize. */
-   png_unknown_chunkp unknown_chunks;
-   png_size_t unknown_chunks_num;
-#endif
-
-#if defined(PNG_iCCP_SUPPORTED)
-   /* iCCP chunk data. */
-   png_charp iccp_name;     /* profile name */
-   png_charp iccp_profile;  /* International Color Consortium profile data */
-                            /* Note to maintainer: should be png_bytep */
-   png_uint_32 iccp_proflen;  /* ICC profile data length */
-   png_byte iccp_compression; /* Always zero */
-#endif
-
-#if defined(PNG_sPLT_SUPPORTED)
-   /* data on sPLT chunks (there may be more than one). */
-   png_sPLT_tp splt_palettes;
-   png_uint_32 splt_palettes_num;
-#endif
-
-#if defined(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;         /* unit of physical scale */
-#ifdef PNG_FLOATING_POINT_SUPPORTED
-   double scal_pixel_width;    /* width of one pixel */
-   double scal_pixel_height;   /* height of one pixel */
-#endif
-#ifdef PNG_FIXED_POINT_SUPPORTED
-   png_charp scal_s_width;     /* string containing height */
-   png_charp scal_s_height;    /* string containing width */
-#endif
-#endif
-
-#if defined(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;        /* the image bits */
-#endif
-
-#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED)
-   png_fixed_point int_gamma; /* 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_fixed_point int_y_white;
-   png_fixed_point int_x_red;
-   png_fixed_point int_y_red;
-   png_fixed_point int_x_green;
-   png_fixed_point int_y_green;
-   png_fixed_point int_x_blue;
-   png_fixed_point int_y_blue;
-#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
-
-#if defined(PNG_USER_CHUNKS_SUPPORTED)
-typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));
-#endif
-#if defined(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 */
-
-/* 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;    /* function for printing errors and aborting */
-   png_error_ptr warning_fn;  /* function for printing warnings */
-   png_voidp error_ptr;       /* user supplied struct for error functions */
-   png_rw_ptr write_data_fn;  /* function for writing output data */
-   png_rw_ptr read_data_fn;   /* function for reading input data */
-   png_voidp io_ptr;          /* ptr to application struct for I/O functions */
-
-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
-   png_user_transform_ptr read_user_transform_fn; /* user read transform */
-#endif
-
-#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
-   png_user_transform_ptr write_user_transform_fn; /* user write transform */
-#endif
-
-/* These were added in libpng-1.0.2 */
-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
-   png_voidp user_transform_ptr; /* user supplied struct for user transform */
-   png_byte user_transform_depth;    /* bit depth of user transformed pixels */
-   png_byte user_transform_channels; /* channels in user transformed pixels */
-#endif
-#endif
-
-   png_uint_32 mode;          /* tells us where we are in the PNG file */
-   png_uint_32 flags;         /* flags indicating various things to libpng */
-   png_uint_32 transformations; /* which transformations to perform */
-
-   z_stream zstream;          /* pointer to decompression structure (below) */
-   png_bytep zbuf;            /* buffer for zlib */
-   png_size_t zbuf_size;      /* size of zbuf */
-   int zlib_level;            /* holds zlib compression level */
-   int zlib_method;           /* holds zlib compression method */
-   int zlib_window_bits;      /* holds zlib compression window bits */
-   int zlib_mem_level;        /* holds zlib compression memory level */
-   int zlib_strategy;         /* holds zlib compression strategy */
-
-   png_uint_32 width;         /* width of image in pixels */
-   png_uint_32 height;        /* height of image in pixels */
-   png_uint_32 num_rows;      /* number of rows in current pass */
-   png_uint_32 usr_width;     /* width of row at start of write */
-   png_uint_32 rowbytes;      /* size of row in bytes */
-   png_uint_32 irowbytes;     /* size of current interlaced row in bytes */
-   png_uint_32 iwidth;        /* width of current interlaced row in pixels */
-   png_uint_32 row_number;    /* current row in interlace pass */
-   png_bytep prev_row;        /* buffer to save previous (unfiltered) row */
-   png_bytep row_buf;         /* buffer to save current (unfiltered) row */
-#ifndef PNG_NO_WRITE_FILTERING
-   png_bytep sub_row;         /* buffer to save "sub" row when filtering */
-   png_bytep up_row;          /* buffer to save "up" row when filtering */
-   png_bytep avg_row;         /* buffer to save "avg" row when filtering */
-   png_bytep paeth_row;       /* buffer to save "Paeth" row when filtering */
-#endif
-   png_row_info row_info;     /* used for transformation routines */
-
-   png_uint_32 idat_size;     /* current IDAT size for read */
-   png_uint_32 crc;           /* current chunk CRC value */
-   png_colorp palette;        /* palette from the input file */
-   png_uint_16 num_palette;   /* number of color entries in palette */
-   png_uint_16 num_trans;     /* number of transparency values */
-   png_byte chunk_name[5];    /* null-terminated name of current chunk */
-   png_byte compression;      /* file compression type (always 0) */
-   png_byte filter;           /* file filter type (always 0) */
-   png_byte interlaced;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
-   png_byte pass;             /* current interlace pass (0 - 6) */
-   png_byte do_filter;        /* row filter flags (see PNG_FILTER_ below ) */
-   png_byte color_type;       /* color type of file */
-   png_byte bit_depth;        /* bit depth of file */
-   png_byte usr_bit_depth;    /* bit depth of users row */
-   png_byte pixel_depth;      /* number of bits per pixel */
-   png_byte channels;         /* number of channels in file */
-   png_byte usr_channels;     /* channels at start of write */
-   png_byte sig_bytes;        /* 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;           /* filler byte for pixel expansion */
-#else
-   png_uint_16 filler;           /* filler bytes for pixel expansion */
-#endif
-#endif
-
-#if defined(PNG_bKGD_SUPPORTED)
-   png_byte background_gamma_type;
-#  ifdef PNG_FLOATING_POINT_SUPPORTED
-   float background_gamma;
-#  endif
-   png_color_16 background;   /* background color in screen gamma space */
-#if defined(PNG_READ_GAMMA_SUPPORTED)
-   png_color_16 background_1; /* background normalized to gamma 1.0 */
-#endif
-#endif /* PNG_bKGD_SUPPORTED */
-
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
-   png_flush_ptr output_flush_fn;/* Function for flushing output */
-   png_uint_32 flush_dist;    /* how many rows apart to flush, 0 - no flush */
-   png_uint_32 flush_rows;    /* number of rows written since last flush */
-#endif
-
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
-   int gamma_shift;      /* number of "insignificant" bits 16-bit gamma */
-#ifdef PNG_FLOATING_POINT_SUPPORTED
-   float gamma;          /* file gamma value */
-   float screen_gamma;   /* screen gamma value (display_exponent) */
-#endif
-#endif
-
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_bytep gamma_table;     /* gamma table for 8-bit depth files */
-   png_bytep gamma_from_1;    /* converts from 1.0 to screen */
-   png_bytep gamma_to_1;      /* converts from file to 1.0 */
-   png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
-   png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
-   png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
-#endif
-
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)
-   png_color_8 sig_bit;       /* significant bits in each available channel */
-#endif
-
-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
-   png_color_8 shift;         /* 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;           /* transparency values for paletted files */
-   png_color_16 trans_values; /* transparency values for non-paletted files */
-#endif
-
-   png_read_status_ptr read_row_fn;   /* called after each row is decoded */
-   png_write_status_ptr write_row_fn; /* called after each row is encoded */
-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
-   png_progressive_info_ptr info_fn; /* called after header data fully read */
-   png_progressive_row_ptr row_fn;   /* called after each prog. row is decoded */
-   png_progressive_end_ptr end_fn;   /* called after image is complete */
-   png_bytep save_buffer_ptr;        /* current location in save_buffer */
-   png_bytep save_buffer;            /* buffer for previously read data */
-   png_bytep current_buffer_ptr;     /* current location in current_buffer */
-   png_bytep current_buffer;         /* buffer for recently used data */
-   png_uint_32 push_length;          /* size of current input chunk */
-   png_uint_32 skip_length;          /* bytes to skip in input data */
-   png_size_t save_buffer_size;      /* amount of data now in save_buffer */
-   png_size_t save_buffer_max;       /* total size of save_buffer */
-   png_size_t buffer_size;           /* total amount of available input data */
-   png_size_t current_buffer_size;   /* amount of data now in current_buffer */
-   int process_mode;                 /* what push library is currently doing */
-   int cur_palette;                  /* current push library palette index */
-
-#  if defined(PNG_TEXT_SUPPORTED)
-     png_size_t current_text_size;   /* current size of text input data */
-     png_size_t current_text_left;   /* how much text left to read in input */
-     png_charp current_text;         /* current text chunk buffer */
-     png_charp current_text_ptr;     /* 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_bytep offset_table;
-   png_uint_16 offset_table_number;
-   png_uint_16 offset_table_count;
-   png_uint_16 offset_table_count_free;
-#endif
-
-#if defined(PNG_READ_DITHER_SUPPORTED)
-   png_bytep palette_lookup;         /* lookup table for dithering */
-   png_bytep dither_index;           /* index translation for palette files */
-#endif
-
-#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED)
-   png_uint_16p hist;                /* histogram */
-#endif
-
-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
-   png_byte heuristic_method;        /* heuristic for row filter selection */
-   png_byte num_prev_filters;        /* number of weights for previous rows */
-   png_bytep prev_filters;           /* filter type(s) of previous row(s) */
-   png_uint_16p filter_weights;      /* weight(s) for previous line(s) */
-   png_uint_16p inv_filter_weights;  /* 1/weight(s) for previous line(s) */
-   png_uint_16p filter_costs;        /* relative filter calculation cost */
-   png_uint_16p inv_filter_costs;    /* 1/relative filter calculation cost */
-#endif
-
-#if defined(PNG_TIME_RFC1123_SUPPORTED)
-   png_charp time_buffer;            /* 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;       /* flags items libpng is responsible for freeing */
-#endif
-
-#if defined(PNG_USER_CHUNKS_SUPPORTED)
-   png_voidp user_chunk_ptr;
-   png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */
-#endif
-
-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
-   int num_chunk_list;
-   png_bytep chunk_list;
-#endif
-
-/* New members added in libpng-1.0.3 */
-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
-   png_byte rgb_to_gray_status;
-   /* These were changed from png_byte in libpng-1.0.6 */
-   png_uint_16 rgb_to_gray_red_coeff;
-   png_uint_16 rgb_to_gray_green_coeff;
-   png_uint_16 rgb_to_gray_blue_coeff;
-#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;
-#else
-   png_uint_32 mng_features_permitted;
-#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;
-#endif
-
-/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */
-#if defined(PNG_MNG_FEATURES_SUPPORTED)
-   png_byte filter_type;
-#endif
-
-#if defined(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;
-#endif
-
-/* New members added in libpng-1.2.0 */
-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-#  if !defined(PNG_1_0_X)
-#    if defined(PNG_MMX_CODE_SUPPORTED)
-   png_byte     mmx_bitdepth_threshold;
-   png_uint_32  mmx_rowbytes_threshold;
-#    endif
-   png_uint_32  asm_flags;
-#  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;                /* user supplied struct for mem functions */
-   png_malloc_ptr malloc_fn;         /* function for allocating memory */
-   png_free_ptr free_fn;             /* function for freeing memory */
-#endif
-
-/* New member added in libpng-1.0.13 and 1.2.0 */
-   png_bytep big_row_buf;         /* buffer to save current (unfiltered) row */
-
-#if defined(PNG_READ_DITHER_SUPPORTED)
-/* The following three members were added at version 1.0.14 and 1.2.4 */
-   png_bytep dither_sort;            /* working sort array */
-   png_bytep index_to_palette;       /* where the original index currently is */
-                                     /* in the palette */
-   png_bytep palette_to_index;       /* 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;
-
-#ifdef PNG_SET_USER_LIMITS_SUPPORTED
-   png_uint_32 user_width_max;
-   png_uint_32 user_height_max;
-#endif
-
-/* New member added in libpng-1.0.25 and 1.2.17 */
-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
-   /* storage for unknown chunk that the library doesn't recognize. */
-   png_unknown_chunk unknown_chunk;
-#endif
-
-/* New members added in libpng-1.2.26 */
-  png_uint_32 old_big_row_buf_size, old_prev_row_size;
-};
-
-
-/* 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_29;
-
-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));
-
-/* 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));
-
-/* 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));
-
-#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));
-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));
-#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));
-
-#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));
-#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));
-
-#ifndef PNG_NO_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
-
-#if defined(PNG_TIME_RFC1123_SUPPORTED)
-extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)
-   PNGARG((png_structp png_ptr, png_timep ptime));
-#endif
-
-#if !defined(_WIN32_WCE)
-/* "time.h" functions are not supported on WindowsCE */
-#if defined(PNG_WRITE_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_WRITE_tIME_SUPPORTED */
-#endif /* _WIN32_WCE */
-
-#if defined(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));
-#if !defined(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));
-#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
-
-#if defined(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
-
-#if defined(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));
-
-#if defined(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. */
-#if !defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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));
-#endif
-#endif
-
-#if defined(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));
-
-/* 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));
-
-/* 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.
- */
-
-#if !defined(PNG_NO_STDIO)
-/* 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).
- */
-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));
-
-#if defined(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));
-#endif
-
-/* frees a pointer allocated by png_malloc() */
-extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));
-
-#if defined(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));
-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));
-
-/* 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));
-#else
-/* Fatal error in PNG image of libpng - can't continue */
-extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr));
-#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));
-
-#if defined(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));
-
-#if defined(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
-
-#if defined(PNG_bKGD_SUPPORTED)
-extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,
-   png_infop info_ptr, png_color_16p background));
-#endif
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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));
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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));
-
-#if defined(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
-
-#if defined(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
-
-#if defined(PNG_sRGB_SUPPORTED)
-extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,
-   png_infop info_ptr, int *intent));
-#endif
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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
-
-#if defined(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.
- */
-
-#if defined(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
-
-#if defined(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
-
-#if defined(PNG_tIME_SUPPORTED)
-extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,
-   png_infop info_ptr, png_timep mod_time));
-#endif
-
-#if defined(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
-
-#if defined(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
-
-#if defined(PNG_tRNS_SUPPORTED)
-#endif
-
-#if defined(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 */
-
-#if defined(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 */
-
-#if defined(PNG_UNKNOWN_CHUNKS_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));
-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
-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
-PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep
-   chunk_name));
-#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));
-
-#if defined(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)
-#define png_debug(l,m)  _RPT0(_CRT_WARN,m)
-#define png_debug1(l,m,p1)  _RPT1(_CRT_WARN,m,p1)
-#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2)
-#endif
-#else /* PNG_DEBUG_FILE || !_MSC_VER */
-#ifndef PNG_DEBUG_FILE
-#define PNG_DEBUG_FILE stderr
-#endif /* PNG_DEBUG_FILE */
-#if (PNG_DEBUG > 1)
-#define png_debug(l,m) \
-{ \
-     int num_tabs=l; \
-     fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
-       (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \
-}
-#define png_debug1(l,m,p1) \
-{ \
-     int num_tabs=l; \
-     fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
-       (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \
-}
-#define png_debug2(l,m,p1,p2) \
-{ \
-     int num_tabs=l; \
-     fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
-       (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \
-}
-#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 */
-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-#if defined(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 */
-
-#if !defined(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 */
-
-#if !defined(PNG_1_0_X)
-/* png.c, pnggccrd.c, or pngvcrd.c */
-extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));
-#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
-
-#endif /* PNG_1_0_X */
-
-/* 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 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.
- */
-#if defined(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
-
-#if defined(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 */
-                       /*   0x4000000L  unused */
-                       /*   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));
-#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));
-#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));
-
-/* Free memory from internal libpng struct */
-PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));
-
-PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr
-  malloc_fn, png_voidp mem_ptr));
-PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
-   png_free_ptr free_fn, png_voidp mem_ptr));
-
-/* 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));
-
-#ifndef PNG_1_0_X
-/* Function to allocate memory for zlib. */
-PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));
-
-/* Function to free memory for zlib */
-PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));
-
-#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));
-#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));
-
-#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));
-#endif
-
-PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,
-   png_bytep data, png_size_t length));
-
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
-#if !defined(PNG_NO_STDIO)
-PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));
-#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));
-#endif
-#endif /* PNG_1_0_X */
-
-/* Reset the CRC variable */
-PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));
-
-/* 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));
-
-/* 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));
-
-/* 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));
-
-/* 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 png_charp png_decompress_chunk PNGARG((png_structp png_ptr,
-   int comp_type, png_charp chunkdata, png_size_t chunklength,
-   png_size_t prefix_length, png_size_t *data_length));
-#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));
-
-/* 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));
-
-/* 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));
-
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
-PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
-#endif
-
-/* simple function to write the signature */
-PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));
-
-/* 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_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,
-   png_uint_32 num_pal));
-
-PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,
-   png_size_t length));
-
-PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));
-
-#if defined(PNG_WRITE_gAMA_SUPPORTED)
-#ifdef PNG_FLOATING_POINT_SUPPORTED
-PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));
-#endif
-#ifdef PNG_FIXED_POINT_SUPPORTED
-PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point
-    file_gamma));
-#endif
-#endif
-
-#if defined(PNG_WRITE_sBIT_SUPPORTED)
-PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,
-   int color_type));
-#endif
-
-#if defined(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));
-#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));
-#endif
-#endif
-
-#if defined(PNG_WRITE_sRGB_SUPPORTED)
-PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
-   int intent));
-#endif
-
-#if defined(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));
-   /* Note to maintainer: profile should be png_bytep */
-#endif
-
-#if defined(PNG_WRITE_sPLT_SUPPORTED)
-PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,
-   png_sPLT_tp palette));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(PNG_WRITE_bKGD_SUPPORTED)
-PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,
-   png_color_16p values, int color_type));
-#endif
-
-#if defined(PNG_WRITE_hIST_SUPPORTED)
-PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
-   int num_hist));
-#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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(PNG_WRITE_tIME_SUPPORTED)
-PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,
-   png_timep mod_time));
-#endif
-
-#if defined(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));
-#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));
-#endif
-#endif
-#endif
-
-/* Called when finished processing a row of data */
-PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));
-
-/* Internal use only.   Called before first row of data */
-PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));
-
-#if defined(PNG_READ_GAMMA_SUPPORTED)
-PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr));
-#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));
-
-#if defined(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_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));
-#endif
-
-/* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */
-
-#if defined(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));
-#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));
-
-/* 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));
-
-/* Write out the filtered row. */
-PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,
-   png_bytep filtered_row));
-/* 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));
-/* optional call to update the users info structure */
-PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-
-/* these are the functions that do the transformations */
-#if defined(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));
-#endif
-
-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
-PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,
-   png_bytep row));
-#endif
-
-#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
-PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,
-   png_bytep row));
-#endif
-
-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
-PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,
-   png_bytep row));
-#endif
-
-#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
-PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,
-   png_bytep row));
-#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));
-#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));
-#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));
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
-PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,
-   png_bytep row));
-#endif
-
-#if defined(PNG_READ_PACK_SUPPORTED)
-PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));
-#endif
-
-#if defined(PNG_READ_SHIFT_SUPPORTED)
-PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,
-   png_color_8p sig_bits));
-#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));
-#endif
-
-#if defined(PNG_READ_16_TO_8_SUPPORTED)
-PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));
-#endif
-
-#if defined(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));
-
-#  if defined(PNG_CORRECT_PALETTE_SUPPORTED)
-PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
-   png_colorp palette, int num_palette));
-#  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));
-#endif
-
-#if defined(PNG_WRITE_PACK_SUPPORTED)
-PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,
-   png_bytep row, png_uint_32 bit_depth));
-#endif
-
-#if defined(PNG_WRITE_SHIFT_SUPPORTED)
-PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,
-   png_color_8p bit_depth));
-#endif
-
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-#if defined(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));
-#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));
-#endif
-#endif
-
-#if defined(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));
-#endif
-
-#if defined(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_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
-   png_bytep row, png_color_16p trans_value));
-#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_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));
-
-#if defined(PNG_READ_bKGD_SUPPORTED)
-PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_cHRM_SUPPORTED)
-PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_gAMA_SUPPORTED)
-PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_hIST_SUPPORTED)
-PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(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 */
-
-#if defined(PNG_READ_iTXt_SUPPORTED)
-PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_oFFs_SUPPORTED)
-PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_pCAL_SUPPORTED)
-PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_pHYs_SUPPORTED)
-PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_sBIT_SUPPORTED)
-PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_sCAL_SUPPORTED)
-PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_sPLT_SUPPORTED)
-extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif /* PNG_READ_sPLT_SUPPORTED */
-
-#if defined(PNG_READ_sRGB_SUPPORTED)
-PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_tEXt_SUPPORTED)
-PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_tIME_SUPPORTED)
-PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_tRNS_SUPPORTED)
-PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-#if defined(PNG_READ_zTXt_SUPPORTED)
-PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
-   png_uint_32 length));
-#endif
-
-PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,
-   png_infop info_ptr, png_uint_32 length));
-
-PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,
-   png_bytep chunk_name));
-
-/* handle the transformations for reading and writing */
-PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));
-PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));
-
-PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));
-
-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
-PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));
-PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,
-   png_uint_32 length));
-PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));
-PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));
-PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,
-   png_bytep buffer, png_size_t buffer_length));
-PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));
-PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,
-   png_bytep buffer, png_size_t buffer_length));
-PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));
-PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,
-   png_infop info_ptr, png_uint_32 length));
-PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));
-PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));
-#if defined(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_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-#endif
-#if defined(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_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-#endif
-#if defined(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_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,
-   png_infop info_ptr));
-#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_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,
-   png_bytep row));
-#endif
-
-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-#if defined(PNG_MMX_CODE_SUPPORTED)
-/* png.c */ /* PRIVATE */
-PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr));
-#endif
-#endif
-
-#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));
-
-#if defined(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 */
-
-/* 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 */
diff --git a/nand-loader/source/libpng/pngconf.h b/nand-loader/source/libpng/pngconf.h
deleted file mode 100644
index 06a182f..0000000
--- a/nand-loader/source/libpng/pngconf.h
+++ /dev/null
@@ -1,1481 +0,0 @@
-
-/* pngconf.h - machine configurable file for libpng
- *
- * libpng version 1.2.29 - May 8, 2008
- * For conditions of distribution and use, see copyright notice in png.h
- * Copyright (c) 1998-2008 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.)
- */
-
-/* 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 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.
- */
-#if defined(__CYGWIN__)
-#  if defined(ALL_STATIC)
-#    if defined(PNG_BUILD_DLL)
-#      undef PNG_BUILD_DLL
-#    endif
-#    if defined(PNG_USE_DLL)
-#      undef PNG_USE_DLL
-#    endif
-#    if defined(PNG_DLL)
-#      undef PNG_DLL
-#    endif
-#    if !defined(PNG_STATIC)
-#      define PNG_STATIC
-#    endif
-#  else
-#    if defined (PNG_BUILD_DLL)
-#      if defined(PNG_STATIC)
-#        undef PNG_STATIC
-#      endif
-#      if defined(PNG_USE_DLL)
-#        undef PNG_USE_DLL
-#      endif
-#      if !defined(PNG_DLL)
-#        define PNG_DLL
-#      endif
-#    else
-#      if defined(PNG_STATIC)
-#        if defined(PNG_USE_DLL)
-#          undef PNG_USE_DLL
-#        endif
-#        if defined(PNG_DLL)
-#          undef PNG_DLL
-#        endif
-#      else
-#        if !defined(PNG_USE_DLL)
-#          define PNG_USE_DLL
-#        endif
-#        if !defined(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(_WIN32_WCE)
-#  include <windows.h>
-   /* Console I/O functions are not supported on WindowsCE */
-#  define PNG_NO_CONSOLE_IO
-#  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
-#    if !defined(_WIN32_WCE)
-/* "stdio.h" functions are not supported on WindowsCE */
-#      include <stdio.h>
-#    endif
-#  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.
- */
-
-#  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__ already includes setjmp.h;
-         __dont__ include it again.;
-#    endif
-#  endif /* __linux__ */
-
-   /* 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.
- */
-
-#if defined(PNG_FLOATING_POINT_SUPPORTED)
-#  if defined(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
- * was turned on by default in libpng-1.3.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_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
-
-#if defined(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_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 */
-
-#if !defined(PNG_NO_PROGRESSIVE_READ) && \
- !defined(PNG_PROGRESSIVE_READ_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 line: */
-
-#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 */
-
-#if defined(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_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)
-#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 */
-
-#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
-
-#  if defined(__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 */
-
-#if !defined(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 */
-#if !defined(PNG_1_0_X)
-#ifndef PNG_SET_USER_LIMITS_SUPPORTED
-#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED)
-#  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
-
-/* 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
-*/
-
-/* 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_UNKNOWN_CHUNKS
-#  define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
-#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED
-#    define PNG_UNKNOWN_CHUNKS_SUPPORTED
-#  endif
-#  ifndef PNG_NO_HANDLE_AS_UNKNOWN
-#    define PNG_HANDLE_AS_UNKNOWN_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_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 */
-
-#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
-#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS
-#  define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
-#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED
-#    define PNG_UNKNOWN_CHUNKS_SUPPORTED
-#  endif
-#  ifndef PNG_NO_HANDLE_AS_UNKNOWN
-#     ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
-#       define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
-#     endif
-#  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
-
-#endif /* PNG_WRITE_ANCILLARY_CHUNKS_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 reading tIME chunks */
-#if defined(PNG_tIME_SUPPORTED)
-#  if !defined(_WIN32_WCE)
-     /* "time.h" functions are not supported on WindowsCE */
-#    include <time.h>
-#  endif
-#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 */
-#if defined(FAR)
-#  if defined(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
-#if defined(_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.3.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
- */
-#if defined(__CYGWIN__)
-#  if !defined(PNG_STATIC)
-#    if defined(PNG_USE_GLOBAL_ARRAYS)
-#      undef PNG_USE_GLOBAL_ARRAYS
-#    endif
-#    if !defined(PNG_USE_LOCAL_ARRAYS)
-#      define PNG_USE_LOCAL_ARRAYS
-#    endif
-#  else
-#    if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS)
-#      if defined(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
-
-#if defined(__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
-
-#  if !defined(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
-#           if defined(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
-
-#     if !defined(PNG_IMPEXP)
-#        if defined(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
-
-/* 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
-
-#if defined(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 */
diff --git a/nand-loader/source/libpng/pngu/pngu.c b/nand-loader/source/libpng/pngu/pngu.c
deleted file mode 100644
index e2cfb7f..0000000
--- a/nand-loader/source/libpng/pngu/pngu.c
+++ /dev/null
@@ -1,1132 +0,0 @@
-/********************************************************************************************
-
-PNGU Version : 0.2a
-
-Coder : frontier
-
-More info : http://frontier-dev.net
-
-********************************************************************************************/
-#include <stdio.h>
-#include <malloc.h>
-#include "pngu.h"
-#include "../png.h"
-
-
-// Constants
-#define PNGU_SOURCE_BUFFER			1
-#define PNGU_SOURCE_DEVICE			2
-
-
-// Prototypes of helper functions
-int pngu_info (IMGCTX ctx);
-int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlpha);
-void pngu_free_info (IMGCTX ctx);
-void pngu_read_data_from_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
-void pngu_write_data_to_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
-void pngu_flush_data_to_buffer (png_structp png_ptr);
-int pngu_clamp (int value, int min, int max);
-
-
-// PNGU Image context struct
-struct _IMGCTX
-{
-	int source;
-	void *buffer;
-	char *filename;
-	PNGU_u32 cursor;
-
-	PNGU_u32 propRead;
-	PNGUPROP prop;
-
-	PNGU_u32 infoRead;
-	png_structp png_ptr;
-	png_infop info_ptr;
-	FILE *fd;
-	
-	png_bytep *row_pointers;
-	png_bytep img_data;
-};
-
-
-// PNGU Implementation //
-
-IMGCTX PNGU_SelectImageFromBuffer (const void *buffer)
-{
-	IMGCTX ctx = NULL;
-
-	if (!buffer)
-		return NULL;
-
-	ctx = malloc (sizeof (struct _IMGCTX));
-	if (!ctx)
-		return NULL;
-
-	ctx->buffer = (void *) buffer;
-	ctx->source = PNGU_SOURCE_BUFFER;
-	ctx->cursor = 0;
-	ctx->filename = NULL;
-	ctx->propRead = 0;
-	ctx->infoRead = 0;
-
-	return ctx;
-}
-
-
-IMGCTX PNGU_SelectImageFromDevice (const char *filename)
-{
-	IMGCTX ctx = NULL;
-
-	if (!filename)
-		return NULL;
-
-	ctx = malloc (sizeof (struct _IMGCTX));
-	if (!ctx)
-		return NULL;
-
-	ctx->buffer = NULL;
-	ctx->source = PNGU_SOURCE_DEVICE;
-	ctx->cursor = 0;
-
-	ctx->filename = malloc (strlen (filename) + 1);
-	if (!ctx->filename)
-	{
-		free (ctx);
-		return NULL;
-	}
-	strcpy(ctx->filename, filename);
-
-	ctx->propRead = 0;
-	ctx->infoRead = 0;
-
-	return ctx;
-}
-
-
-void PNGU_ReleaseImageContext (IMGCTX ctx)
-{
-	if (!ctx)
-		return;
-
-	if (ctx->filename)
-		free (ctx->filename);
-
-	if ((ctx->propRead) && (ctx->prop.trans))
-		free (ctx->prop.trans);
-
-	pngu_free_info (ctx);
-
-	free (ctx);
-}
-
-
-int PNGU_GetImageProperties (IMGCTX ctx, PNGUPROP *imgprop)
-{
-	int res;
-
-	if (!ctx->propRead)
-	{
-		res = pngu_info (ctx);
-		if (res != PNGU_OK)
-			return res;
-	}
-
-	*imgprop = ctx->prop;
-
-	return PNGU_OK;
-}
-
-
-int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
-{
-	int result;
-	PNGU_u32 x, y, buffWidth;
-
-	// width needs to be divisible by two
-	if (width % 2)
-		return PNGU_ODD_WIDTH;
-
-	// stride needs to be divisible by two
-	if (stride % 2)
-		return PNGU_ODD_STRIDE;
-
-	result = pngu_decode (ctx, width, height, 1);
-	if (result != PNGU_OK)
-		return result;
-
-	// Copy image to the output buffer
-	buffWidth = (width + stride) / 2;
-	for (y = 0; y < height; y++)
-		for (x = 0; x < (width / 2); x++)
-			((PNGU_u32 *)buffer)[y*buffWidth+x] = PNGU_RGB8_TO_YCbYCr (*(ctx->row_pointers[y]+x*6), *(ctx->row_pointers[y]+x*6+1), *(ctx->row_pointers[y]+x*6+2),
-															*(ctx->row_pointers[y]+x*6+3), *(ctx->row_pointers[y]+x*6+4), *(ctx->row_pointers[y]+x*6+5));
-	
-	// Free resources
-	free (ctx->img_data);
-	free (ctx->row_pointers);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
-{
-	int result;
-	PNGU_u32 x, y, buffWidth;
-	
-	result = pngu_decode (ctx, width, height, 1);
-	if (result != PNGU_OK)
-		return result;
-
-	buffWidth = width + stride;
-
-	// Copy image to the output buffer
-	for (y = 0; y < height; y++)
-		for (x = 0; x < width; x++)
-			((PNGU_u16 *)buffer)[y*buffWidth+x] = 
-				(((PNGU_u16) (ctx->row_pointers[y][x*3] & 0xF8)) << 8) | 
-				(((PNGU_u16) (ctx->row_pointers[y][x*3+1] & 0xFC)) << 3) | 
-				(((PNGU_u16) (ctx->row_pointers[y][x*3+2] & 0xF8)) >> 3);
-	
-	// Free resources
-	free (ctx->img_data);
-	free (ctx->row_pointers);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride, PNGU_u8 default_alpha)
-{
-	int result;
-	PNGU_u32 x, y, buffWidth;
-	
-	result = pngu_decode (ctx, width, height, 0);
-	if (result != PNGU_OK)
-		return result;
-
-	buffWidth = width + stride;
-
-	// Check is source image has an alpha channel
-	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
-	{
-		// Alpha channel present, copy image to the output buffer
-		for (y = 0; y < height; y++)
-			memcpy (buffer + (y * buffWidth * 4), ctx->row_pointers[y], width * 4);
-	}
-	else
-	{
-		// No alpha channel present, copy image to the output buffer
-		for (y = 0; y < height; y++)
-			for (x = 0; x < width; x++)
-				((PNGU_u32 *)buffer)[y*buffWidth+x] = 
-					(((PNGU_u32) ctx->row_pointers[y][x*3]) << 24) | 
-					(((PNGU_u32) ctx->row_pointers[y][x*3+1]) << 16) | 
-					(((PNGU_u32) ctx->row_pointers[y][x*3+2]) << 8) | 
-					((PNGU_u32) default_alpha);
-	}
-	
-	// Free resources
-	free (ctx->img_data);
-	free (ctx->row_pointers);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer)
-{
-	int result;
-	PNGU_u32 x, y, qwidth, qheight;
-
-	// width and height need to be divisible by four
-	if ((width % 4) || (height % 4))
-		return PNGU_INVALID_WIDTH_OR_HEIGHT;
-
-	result = pngu_decode (ctx, width, height, 1);
-	if (result != PNGU_OK)
-		return result;
-
-	// Copy image to the output buffer
-	qwidth = width / 4;
-	qheight = height / 4;
-
-	for (y = 0; y < qheight; y++)
-		for (x = 0; x < qwidth; x++)
-		{
-			int blockbase = (y * qwidth + x) * 4;
-
-			PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
-			PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
-			((PNGU_u64 *) buffer)[blockbase] = 
-				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
-				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
-				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
-				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
-
-			field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
-			field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
-			((PNGU_u64 *) buffer)[blockbase+1] = 
-				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
-				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
-				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
-				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
-
-			field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
-			field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
-			((PNGU_u64 *) buffer)[blockbase+2] = 
-				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
-				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
-				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
-				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
-
-			field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
-			field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
-			((PNGU_u64 *) buffer)[blockbase+3] = 
-				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
-				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
-				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
-				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
-		}
-	
-	// Free resources
-	free (ctx->img_data);
-	free (ctx->row_pointers);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha)
-{
-	int result;
-	PNGU_u32 x, y, qwidth, qheight;
-	PNGU_u64 alphaMask;
-
-	// width and height need to be divisible by four
-	if ((width % 4) || (height % 4))
-		return PNGU_INVALID_WIDTH_OR_HEIGHT;
-
-	result = pngu_decode (ctx, width, height, 0);
-	if (result != PNGU_OK)
-		return result;
-
-	// Init some vars
-	qwidth = width / 4;
-	qheight = height / 4;
-
-	// Check is source image has an alpha channel
-	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
-	{
-		// Alpha channel present, copy image to the output buffer
-		for (y = 0; y < qheight; y++)
-			for (x = 0; x < qwidth; x++)
-			{
-				int blockbase = (y * qwidth + x) * 4;
-				PNGU_u64 tmp;
-
-				PNGU_u64 fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16));
-				PNGU_u64 fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16+8));
-				// If first pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
-				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)			
-					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
-				else
-					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
-
-				// If second pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
-				if ((fieldA & 0xE0ULL) == 0xE0ULL)
-					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
-				else
-					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
-
-				// If third pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
-				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
-					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
-				else
-					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
-
-				// If fourth pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
-				if ((fieldB & 0xE0ULL) == 0xE0ULL)
-					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
-				else
-					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
-				((PNGU_u64 *) buffer)[blockbase] = tmp;
-
-				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16));
-				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16+8));
-				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
-
-				if ((fieldA & 0xE0ULL) == 0xE0ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
-
-				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
-
-				if ((fieldB & 0xE0ULL) == 0xE0ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
-				((PNGU_u64 *) buffer)[blockbase+1] = tmp;
-
-				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16));
-				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16+8));
-				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
-
-				if ((fieldA & 0xE0ULL) == 0xE0ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
-
-				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
-
-				if ((fieldB & 0xE0ULL) == 0xE0ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
-				((PNGU_u64 *) buffer)[blockbase+2] = tmp;
-
-				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16));
-				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16+8));
-				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
-
-				if ((fieldA & 0xE0ULL) == 0xE0ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
-
-				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
-
-				if ((fieldB & 0xE0ULL) == 0xE0ULL)
-					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
-					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
-				else
-					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
-					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
-				((PNGU_u64 *) buffer)[blockbase+3] = tmp;
-			}
-	}
-	else
-	{
-		// No alpha channel present, copy image to the output buffer
-		default_alpha = (default_alpha >> 5);
-		if (default_alpha == 7)
-		{
-			// The user wants an opaque texture, so set MSB to 1 and encode colors in RGB555
-			alphaMask = 0x8000800080008000ULL;
-
-			for (y = 0; y < qheight; y++)
-				for (x = 0; x < qwidth; x++)
-				{
-					int blockbase = (y * qwidth + x) * 4;
-
-					PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
-					PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase] = 
-						 alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
-						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
-						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
-						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
-
-					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
-					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase+1] = 
-						alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
-						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
-						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
-						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
-
-					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
-					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase+2] = 
-						alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
-						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
-						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
-						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
-
-					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
-					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase+3] = 
-						alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
-						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
-						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
-						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
-				}
-		}
-		else
-		{
-			// The user wants a translucid texture, so set MSB to 0 and encode colors in ARGB3444
-			default_alpha = (default_alpha << 4);
-			alphaMask = (((PNGU_u64) default_alpha) << 56) | (((PNGU_u64) default_alpha) << 40) |
-						(((PNGU_u64) default_alpha) << 24) | (((PNGU_u64) default_alpha) << 8);
-
-			for (y = 0; y < qheight; y++)
-				for (x = 0; x < qwidth; x++)
-				{
-					int blockbase = (y * qwidth + x) * 4;
-
-					PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
-					PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase] = 
-						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
-						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
-						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
-						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
-
-					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
-					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase+1] = 
-						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
-						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
-						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
-						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
-
-					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
-					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase+2] = 
-						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
-						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
-						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
-						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
-
-					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
-					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
-					((PNGU_u64 *) buffer)[blockbase+3] = 
-						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
-						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
-						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
-						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
-				}
-		}
-	}
-	
-	// Free resources
-	free (ctx->img_data);
-	free (ctx->row_pointers);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-int PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha)
-{
-	int result;
-	PNGU_u32 x, y, qwidth, qheight;
-	PNGU_u64 alphaMask;
-
-	// width and height need to be divisible by four
-	if ((width % 4) || (height % 4))
-		return PNGU_INVALID_WIDTH_OR_HEIGHT;
-
-	result = pngu_decode (ctx, width, height, 0);
-	if (result != PNGU_OK)
-		return result;
-
-	// Init some variables
-	qwidth = width / 4;
-	qheight = height / 4;
-
-	// Check is source image has an alpha channel
-	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
-	{
-		// Alpha channel present, copy image to the output buffer
-		for (y = 0; y < qheight; y++)
-			for (x = 0; x < qwidth; x++)
-			{
-				int blockbase = (y * qwidth + x) * 8;
-
-				PNGU_u64 fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16));
-				PNGU_u64 fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16+8));
-				((PNGU_u64 *) buffer)[blockbase] = 
-					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
-					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
-					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
-					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
-				((PNGU_u64 *) buffer)[blockbase+4] =
-					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
-					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
-
-				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16));
-				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16+8));
-				((PNGU_u64 *) buffer)[blockbase+1] = 
-					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
-					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
-					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
-					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
-				((PNGU_u64 *) buffer)[blockbase+5] =
-					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
-					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
-
-				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16));
-				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16+8));
-				((PNGU_u64 *) buffer)[blockbase+2] = 
-					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
-					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
-					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
-					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
-				((PNGU_u64 *) buffer)[blockbase+6] =
-					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
-					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
-
-				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16));
-				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16+8));
-				((PNGU_u64 *) buffer)[blockbase+3] = 
-					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
-					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
-					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
-					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
-				((PNGU_u64 *) buffer)[blockbase+7] =
-					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
-					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
-			}
-	}
-	else
-	{
-		// No alpha channel present, copy image to the output buffer
-		alphaMask = (((PNGU_u64)default_alpha) << 56) | (((PNGU_u64)default_alpha) << 40) |
-					(((PNGU_u64)default_alpha) << 24) | (((PNGU_u64)default_alpha) << 8);
-
-		for (y = 0; y < qheight; y++)
-			for (x = 0; x < qwidth; x++)
-			{
-				int blockbase = (y * qwidth + x) * 8;
-
-				PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
-				PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
-				((PNGU_u64 *) buffer)[blockbase] = 
-					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
-					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
-				((PNGU_u64 *) buffer)[blockbase+4] =
-					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
-					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
-
-				field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
-				field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
-				((PNGU_u64 *) buffer)[blockbase+1] = 
-					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
-					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
-				((PNGU_u64 *) buffer)[blockbase+5] =
-					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
-					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
-
-				field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
-				field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
-				((PNGU_u64 *) buffer)[blockbase+2] = 
-					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
-					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
-				((PNGU_u64 *) buffer)[blockbase+6] =
-					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
-					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
-
-				field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
-				field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
-				((PNGU_u64 *) buffer)[blockbase+3] = 
-					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
-					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
-				((PNGU_u64 *) buffer)[blockbase+7] =
-					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
-					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
-			}
-	}
-	
-	// Free resources
-	free (ctx->img_data);
-	free (ctx->row_pointers);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
-{
-	png_uint_32 rowbytes;
-	PNGU_u32 x, y, buffWidth;
-
-	// Erase from the context any readed info
-	pngu_free_info (ctx);
-	ctx->propRead = 0;
-
-	// Check if the user has selected a file to write the image
-	if (ctx->source == PNGU_SOURCE_BUFFER);	
-
-	else if (ctx->source == PNGU_SOURCE_DEVICE)
-	{
-		// Open file
-		if (!(ctx->fd = fopen (ctx->filename, "wb")))
-			return PNGU_CANT_OPEN_FILE;
-	}
-
-	else
-		return PNGU_NO_FILE_SELECTED;
-
-	// Allocation of libpng structs
-	ctx->png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-    if (!(ctx->png_ptr))
-	{
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-        return PNGU_LIB_ERROR;
-	}
-
-    ctx->info_ptr = png_create_info_struct (ctx->png_ptr);
-    if (!(ctx->info_ptr))
-    {
-		png_destroy_write_struct (&(ctx->png_ptr), (png_infopp)NULL);
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-        return PNGU_LIB_ERROR;
-    }
-
-	if (ctx->source == PNGU_SOURCE_BUFFER)
-	{
-		// Installation of our custom data writer function
-		ctx->cursor = 0;
-		png_set_write_fn (ctx->png_ptr, ctx, pngu_write_data_to_buffer, pngu_flush_data_to_buffer);
-	}
-	else if (ctx->source == PNGU_SOURCE_DEVICE)
-	{
-		// Default data writer uses function fwrite, so it needs to use our FILE*
-		png_init_io (ctx->png_ptr, ctx->fd);
-	}
-
-	// Setup output file properties
-    png_set_IHDR (ctx->png_ptr, ctx->info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB, 
-				PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-
-	// Allocate memory to store the image in RGB format
-	rowbytes = width * 3;
-	if (rowbytes % 4)
-		rowbytes = ((rowbytes / 4) + 1) * 4; // Add extra padding so each row starts in a 4 byte boundary
-
-	ctx->img_data = malloc (rowbytes * height);
-	if (!ctx->img_data)
-	{
-		png_destroy_write_struct (&(ctx->png_ptr), (png_infopp)NULL);
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-		return PNGU_LIB_ERROR;
-	}
-
-	ctx->row_pointers = malloc (sizeof (png_bytep) * height);
-	if (!ctx->row_pointers)
-	{
-		png_destroy_write_struct (&(ctx->png_ptr), (png_infopp)NULL);
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-		return PNGU_LIB_ERROR;
-	}
-
-	// Encode YCbYCr image into RGB8 format
-	buffWidth = (width + stride) / 2;
-	for (y = 0; y < height; y++)
-	{
-		ctx->row_pointers[y] = ctx->img_data + (y * rowbytes);
-
-		for (x = 0; x < (width / 2); x++)
-			PNGU_YCbYCr_TO_RGB8 ( ((PNGU_u32 *)buffer)[y*buffWidth+x], 
-				((PNGU_u8 *) ctx->row_pointers[y]+x*6), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+1),
-				((PNGU_u8 *) ctx->row_pointers[y]+x*6+2), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+3),
-				((PNGU_u8 *) ctx->row_pointers[y]+x*6+4), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+5) );
-	}
-
-	// Tell libpng where is our image data
-	png_set_rows (ctx->png_ptr, ctx->info_ptr, ctx->row_pointers);
-
-	// Write file header and image data
-	png_write_png (ctx->png_ptr, ctx->info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
-
-	// Tell libpng we have no more data to write
-	png_write_end (ctx->png_ptr, (png_infop) NULL);
-
-	// Free resources
-	free (ctx->img_data);
-	free (ctx->row_pointers);
-	png_destroy_write_struct (&(ctx->png_ptr), &(ctx->info_ptr));
-	if (ctx->source == PNGU_SOURCE_DEVICE)
-		fclose (ctx->fd);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-// This function is taken from a libogc example
-PNGU_u32 PNGU_RGB8_TO_YCbYCr (PNGU_u8 r1, PNGU_u8 g1, PNGU_u8 b1, PNGU_u8 r2, PNGU_u8 g2, PNGU_u8 b2)
-{
-  int y1, cb1, cr1, y2, cb2, cr2, cb, cr;
-
-  y1 = (299 * r1 + 587 * g1 + 114 * b1) / 1000;
-  cb1 = (-16874 * r1 - 33126 * g1 + 50000 * b1 + 12800000) / 100000;
-  cr1 = (50000 * r1 - 41869 * g1 - 8131 * b1 + 12800000) / 100000;
- 
-  y2 = (299 * r2 + 587 * g2 + 114 * b2) / 1000;
-  cb2 = (-16874 * r2 - 33126 * g2 + 50000 * b2 + 12800000) / 100000;
-  cr2 = (50000 * r2 - 41869 * g2 - 8131 * b2 + 12800000) / 100000;
- 
-  cb = (cb1 + cb2) >> 1;
-  cr = (cr1 + cr2) >> 1;
- 
-  return (PNGU_u32) ((y1 << 24) | (cb << 16) | (y2 << 8) | cr);
-}
-
-
-void PNGU_YCbYCr_TO_RGB8 (PNGU_u32 ycbycr, PNGU_u8 *r1, PNGU_u8 *g1, PNGU_u8 *b1, PNGU_u8 *r2, PNGU_u8 *g2, PNGU_u8 *b2)
-{
-	PNGU_u8 *val = (PNGU_u8 *) &ycbycr;
-	int r, g, b;
-
-	r = 1.371f * (val[3] - 128);
-	g = - 0.698f * (val[3] - 128) - 0.336f * (val[1] - 128);
-	b = 1.732f * (val[1] - 128);
-
-	*r1 = pngu_clamp (val[0] + r, 0, 255);
-	*g1 = pngu_clamp (val[0] + g, 0, 255);
-	*b1 = pngu_clamp (val[0] + b, 0, 255);
-
-	*r2 = pngu_clamp (val[2] + r, 0, 255);
-	*g2 = pngu_clamp (val[2] + g, 0, 255);
-	*b2 = pngu_clamp (val[2] + b, 0, 255);
-}
-
-
-int pngu_info (IMGCTX ctx)
-{
-	png_byte magic[8];
-	png_uint_32 width;
-	png_uint_32 height;
-	png_color_16p background;
-	png_bytep trans;
-	png_color_16p trans_values;
-	int scale, i;
-
-	// Check if there is a file selected and if it is a valid .png
-	if (ctx->source == PNGU_SOURCE_BUFFER)
-		memcpy (magic, ctx->buffer, 8);
-
-	else if (ctx->source == PNGU_SOURCE_DEVICE)
-	{
-		// Open file
-		if (!(ctx->fd = fopen (ctx->filename, "rb")))
-			return PNGU_CANT_OPEN_FILE;
-
-		// Load first 8 bytes into magic buffer
-        if (fread (magic, 1, 8, ctx->fd) != 8)
-		{
-			fclose (ctx->fd);
-			return PNGU_CANT_READ_FILE;
-		}
-	}
-
-	else
-		return PNGU_NO_FILE_SELECTED;;
-
-	if (png_sig_cmp(magic, 0, 8) != 0)
-	{
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-		return PNGU_FILE_IS_NOT_PNG;
-	}
-
-	// Allocation of libpng structs
-	ctx->png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-    if (!(ctx->png_ptr))
-	{
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-        return PNGU_LIB_ERROR;
-	}
-
-    ctx->info_ptr = png_create_info_struct (ctx->png_ptr);
-    if (!(ctx->info_ptr))
-    {
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-        png_destroy_read_struct (&(ctx->png_ptr), (png_infopp)NULL, (png_infopp)NULL);
-        return PNGU_LIB_ERROR;
-    }
-
-	if (ctx->source == PNGU_SOURCE_BUFFER)
-	{
-		// Installation of our custom data provider function
-		ctx->cursor = 0;
-		png_set_read_fn (ctx->png_ptr, ctx, pngu_read_data_from_buffer);
-	}
-	else if (ctx->source == PNGU_SOURCE_DEVICE)
-	{
-		// Default data provider uses function fread, so it needs to use our FILE*
-		png_init_io (ctx->png_ptr, ctx->fd);
-		png_set_sig_bytes (ctx->png_ptr, 8); // We have read 8 bytes already to check PNG authenticity
-	}
-
-	// Read png header
-	png_read_info (ctx->png_ptr, ctx->info_ptr);
-
-	// Query image properties if they have not been queried before
-	if (!ctx->propRead)
-	{
-		png_get_IHDR(ctx->png_ptr, ctx->info_ptr, &width, &height,
-					(int *) &(ctx->prop.imgBitDepth), 
-					(int *) &(ctx->prop.imgColorType),
-					NULL, NULL, NULL);
-
-		ctx->prop.imgWidth = width;
-		ctx->prop.imgHeight = height;
-		switch (ctx->prop.imgColorType)
-		{
-			case PNG_COLOR_TYPE_GRAY:
-				ctx->prop.imgColorType = PNGU_COLOR_TYPE_GRAY;
-				break;
-			case PNG_COLOR_TYPE_GRAY_ALPHA:
-				ctx->prop.imgColorType = PNGU_COLOR_TYPE_GRAY_ALPHA;
-				break;
-			case PNG_COLOR_TYPE_PALETTE:
-				ctx->prop.imgColorType = PNGU_COLOR_TYPE_PALETTE;
-				break;
-			case PNG_COLOR_TYPE_RGB:
-				ctx->prop.imgColorType = PNGU_COLOR_TYPE_RGB;
-				break;
-			case PNG_COLOR_TYPE_RGB_ALPHA:
-				ctx->prop.imgColorType = PNGU_COLOR_TYPE_RGB_ALPHA;
-				break;
-			default:
-				ctx->prop.imgColorType = PNGU_COLOR_TYPE_UNKNOWN;
-				break;
-		}
-
-		// Constant used to scale 16 bit values to 8 bit values
-		scale = 1;
-		if (ctx->prop.imgBitDepth == 16)
-			scale = 256;
-
-		// Query background color, if any.
-		ctx->prop.validBckgrnd = 0;
-		if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA)) &&
-			(png_get_bKGD (ctx->png_ptr, ctx->info_ptr, &background)))
-		{
-			ctx->prop.validBckgrnd = 1;
-			ctx->prop.bckgrnd.r = background->red / scale;
-			ctx->prop.bckgrnd.g = background->green / scale;
-			ctx->prop.bckgrnd.b = background->blue / scale;
-		}
-		else if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA)) &&
-			(png_get_bKGD (ctx->png_ptr, ctx->info_ptr, &background)))
-		{
-			ctx->prop.validBckgrnd = 1;
-			ctx->prop.bckgrnd.r = ctx->prop.bckgrnd.g = ctx->prop.bckgrnd.b = background->gray / scale;
-		}
-
-		// Query list of transparent colors, if any.
-		ctx->prop.numTrans = 0;
-		ctx->prop.trans = NULL;
-		if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA)) &&
-			(png_get_tRNS (ctx->png_ptr, ctx->info_ptr, &trans, (int *) &(ctx->prop.numTrans), &trans_values)))
-		{
-			if (ctx->prop.numTrans)
-			{
-				ctx->prop.trans = malloc (sizeof (PNGUCOLOR) * ctx->prop.numTrans);
-				if (ctx->prop.trans)
-					for (i = 0; i < ctx->prop.numTrans; i++)
-					{
-						ctx->prop.trans[i].r = trans_values[i].red / scale;
-						ctx->prop.trans[i].g = trans_values[i].green / scale;
-						ctx->prop.trans[i].b = trans_values[i].blue / scale;
-					}
-				else
-					ctx->prop.numTrans = 0;
-			}
-		}
-		else if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA)) &&
-			(png_get_tRNS (ctx->png_ptr, ctx->info_ptr, &trans, (int *) &(ctx->prop.numTrans), &trans_values)))
-		{
-			if (ctx->prop.numTrans)
-			{
-				ctx->prop.trans = malloc (sizeof (PNGUCOLOR) * ctx->prop.numTrans);
-				if (ctx->prop.trans)
-					for (i = 0; i < ctx->prop.numTrans; i++)
-						ctx->prop.trans[i].r = ctx->prop.trans[i].g = ctx->prop.trans[i].b = 
-						trans_values[i].gray / scale;
-				else
-					ctx->prop.numTrans = 0;
-			}
-		}
-
-		ctx->propRead = 1;
-	}
-
-	// Success
-	ctx->infoRead = 1;
-
-	return PNGU_OK;
-}
-
-
-int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlpha)
-{
-	png_uint_32 rowbytes;
-	int i;
-
-	// Read info if it hasn't been read before
-	if (!ctx->infoRead)
-	{
-		i = pngu_info (ctx);
-		if (i != PNGU_OK)
-			return i;
-	}
-
-	// Check if the user has specified the real width and height of the image
-	if ( (ctx->prop.imgWidth != width) || (ctx->prop.imgHeight != height) )
-		return PNGU_INVALID_WIDTH_OR_HEIGHT;
-
-	// Check if color type is supported by PNGU
-	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_PALETTE) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_UNKNOWN) )
-		return PNGU_UNSUPPORTED_COLOR_TYPE;
-
-	// Scale 16 bit samples to 8 bit
-	if (ctx->prop.imgBitDepth == 16)
-        png_set_strip_16 (ctx->png_ptr);
-
-	// Remove alpha channel if we don't need it
-	if (stripAlpha && ((ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA)))
-        png_set_strip_alpha (ctx->png_ptr);
-
-	// Expand 1, 2 and 4 bit samples to 8 bit
-	if (ctx->prop.imgBitDepth < 8)
-        png_set_packing (ctx->png_ptr);
-
-	// Transform grayscale images to RGB
-	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) )
-		png_set_gray_to_rgb (ctx->png_ptr);
-
-	// Flush transformations
-	png_read_update_info (ctx->png_ptr, ctx->info_ptr);
-
-	// Allocate memory to store the image
-	rowbytes = png_get_rowbytes (ctx->png_ptr, ctx->info_ptr);
-	if (rowbytes % 4)
-		rowbytes = ((rowbytes / 4) + 1) * 4; // Add extra padding so each row starts in a 4 byte boundary
-
-	ctx->img_data = malloc (rowbytes * ctx->prop.imgHeight);
-	if (!ctx->img_data)
-	{
-		pngu_free_info (ctx);
-		return PNGU_LIB_ERROR;
-	}
-
-	ctx->row_pointers = malloc (sizeof (png_bytep) * ctx->prop.imgHeight);
-	if (!ctx->row_pointers)
-	{
-		free (ctx->img_data);
-		pngu_free_info (ctx);
-		return PNGU_LIB_ERROR;
-	}
-
-	for (i = 0; i < ctx->prop.imgHeight; i++)
-		ctx->row_pointers[i] = ctx->img_data + (i * rowbytes);
-
-	// Transform the image and copy it to our allocated memory
-	png_read_image (ctx->png_ptr, ctx->row_pointers);
-
-	// Free resources
-	pngu_free_info (ctx);
-
-	// Success
-	return PNGU_OK;
-}
-
-
-void pngu_free_info (IMGCTX ctx)
-{
-	if (ctx->infoRead)
-	{
-		if (ctx->source == PNGU_SOURCE_DEVICE)
-			fclose (ctx->fd);
-
-		png_destroy_read_struct (&(ctx->png_ptr), &(ctx->info_ptr), (png_infopp)NULL);
-
-		ctx->infoRead = 0;
-	}
-}
-
-
-// Custom data provider function used for reading from memory buffers.
-void pngu_read_data_from_buffer (png_structp png_ptr, png_bytep data, png_size_t length)
-{
-	IMGCTX ctx = (IMGCTX) png_get_io_ptr (png_ptr);
-	memcpy (data, ctx->buffer + ctx->cursor, length);
-	ctx->cursor += length;
-}
-
-
-// Custom data writer function used for writing to memory buffers.
-void pngu_write_data_to_buffer (png_structp png_ptr, png_bytep data, png_size_t length)
-{
-	IMGCTX ctx = (IMGCTX) png_get_io_ptr (png_ptr);
-	memcpy (ctx->buffer + ctx->cursor, data, length);
-	ctx->cursor += length;
-}
-
-
-// Custom data flusher function used for writing to memory buffers.
-void pngu_flush_data_to_buffer (png_structp png_ptr)
-{
-	// Nothing to do here
-}
-
-
-// Function used in YCbYCr to RGB decoding
-int pngu_clamp (int value, int min, int max)
-{
-	if (value < min)
-		value = min;
-	else if (value > max)
-		value = max;
-
-	return value;
-}
-
diff --git a/nand-loader/source/libpng/pngu/pngu.h b/nand-loader/source/libpng/pngu/pngu.h
deleted file mode 100644
index b5e172b..0000000
--- a/nand-loader/source/libpng/pngu/pngu.h
+++ /dev/null
@@ -1,171 +0,0 @@
-/********************************************************************************************
-
-PNGU Version : 0.2a
-
-Coder : frontier
-
-More info : http://frontier-dev.net
-
-********************************************************************************************/
-#ifndef __PNGU__
-#define __PNGU__
-
-// Return codes
-#define PNGU_OK							0
-#define PNGU_ODD_WIDTH					1
-#define PNGU_ODD_STRIDE					2
-#define PNGU_INVALID_WIDTH_OR_HEIGHT	3
-#define PNGU_FILE_IS_NOT_PNG			4
-#define PNGU_UNSUPPORTED_COLOR_TYPE		5
-#define PNGU_NO_FILE_SELECTED			6
-#define PNGU_CANT_OPEN_FILE				7
-#define PNGU_CANT_READ_FILE				8
-#define PNGU_LIB_ERROR					9
-
-// Color types
-#define PNGU_COLOR_TYPE_GRAY			1
-#define PNGU_COLOR_TYPE_GRAY_ALPHA		2
-#define PNGU_COLOR_TYPE_PALETTE			3
-#define PNGU_COLOR_TYPE_RGB				4
-#define PNGU_COLOR_TYPE_RGB_ALPHA		5
-#define PNGU_COLOR_TYPE_UNKNOWN 		6
-
-
-#ifdef __cplusplus
-	extern "C" {
-#endif
-
-// Types
-typedef unsigned char PNGU_u8;
-typedef unsigned short PNGU_u16;
-typedef unsigned int PNGU_u32;
-typedef unsigned long long PNGU_u64;
-
-typedef struct
-{
-	PNGU_u8 r;
-	PNGU_u8 g;
-	PNGU_u8 b;
-} PNGUCOLOR;
-
-typedef struct
-{
-	PNGU_u32 imgWidth; // In pixels
-	PNGU_u32 imgHeight; // In pixels
-	PNGU_u32 imgBitDepth; // In bitx
-	PNGU_u32 imgColorType; // PNGU_COLOR_TYPE_*
-	PNGU_u32 validBckgrnd; // Non zero if there is a background color
-	PNGUCOLOR bckgrnd; // Backgroun color
-	PNGU_u32 numTrans; // Number of transparent colors
-	PNGUCOLOR *trans; // Transparent colors
-} PNGUPROP;
-
-// Image context, always initialize with SelectImageFrom* and free with ReleaseImageContext
-struct _IMGCTX;
-typedef struct _IMGCTX *IMGCTX; 
-
-
-/****************************************************************************
-*							 Pixel conversion								*
-****************************************************************************/
-
-// Macro to convert RGB8 values to RGB565
-#define PNGU_RGB8_TO_RGB565(r,g,b) ( ((((PNGU_u16) r) & 0xF8U) << 8) | ((((PNGU_u16) g) & 0xFCU) << 3) | (((PNGU_u16) b) >> 3) )
-
-// Macro to convert RGBA8 values to RGB5A3
-#define PNGU_RGB8_TO_RGB5A3(r,g,b,a)	(PNGU_u16) (((a & 0xE0U) == 0xE0U) ? \
-										(0x8000U | ((((PNGU_u16) r) & 0xF8U) << 7) | ((((PNGU_u16) g) & 0xF8U) << 2) | (((PNGU_u16) b) >> 3)) : \
-										(((((PNGU_u16) a) & 0xE0U) << 7) | ((((PNGU_u16) r) & 0xF0U) << 4) | (((PNGU_u16) g) & 0xF0U) | ((((PNGU_u16) b) & 0xF0U) >> 4)))
-
-// Function to convert two RGB8 values to YCbYCr
-PNGU_u32 PNGU_RGB8_TO_YCbYCr (PNGU_u8 r1, PNGU_u8 g1, PNGU_u8 b1, PNGU_u8 r2, PNGU_u8 g2, PNGU_u8 b2);
-
-// Function to convert an YCbYCr to two RGB8 values.
-void PNGU_YCbYCr_TO_RGB8 (PNGU_u32 ycbycr, PNGU_u8 *r1, PNGU_u8 *g1, PNGU_u8 *b1, PNGU_u8 *r2, PNGU_u8 *g2, PNGU_u8 *b2);
-
-
-/****************************************************************************
-*							 Image context handling							*
-****************************************************************************/
-
-// Selects a PNG file, previosly loaded into a buffer, and creates an image context for subsequent procesing.
-IMGCTX PNGU_SelectImageFromBuffer (const void *buffer);
-
-// Selects a PNG file, from any devoptab device, and creates an image context for subsequent procesing.
-IMGCTX PNGU_SelectImageFromDevice (const char *filename);
-
-// Frees resources associated with an image context. Always call this function when you no longer need the IMGCTX.
-void PNGU_ReleaseImageContext (IMGCTX ctx);
-
-
-/****************************************************************************
-*							 Miscelaneous									*
-****************************************************************************/
-
-// Retrieves info from selected PNG file, including image dimensions, color format, background and transparency colors.
-int PNGU_GetImageProperties (IMGCTX ctx, PNGUPROP *fileproperties);
-
-
-/****************************************************************************
-*							 Image conversion								*
-****************************************************************************/
-
-// Expands selected image into an YCbYCr buffer. You need to specify context, image dimensions, 
-// destination address and stride in pixels (stride = buffer width - image width).
-int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
-
-// Macro for decoding an image inside a buffer at given coordinates.
-#define PNGU_DECODE_TO_COORDS_YCbYCr(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer)	\
-																											\
-		PNGU_DecodeToYCbYCr (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 +	\
-							(coordX) * 2, (bufferWidth) - (imgWidth))
-
-// Expands selected image into a linear RGB565 buffer. You need to specify context, image dimensions, 
-// destination address and stride in pixels (stride = buffer width - image width).
-int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
-
-// Macro for decoding an image inside a buffer at given coordinates.
-#define PNGU_DECODE_TO_COORDS_RGB565(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer)	\
-																											\
-		PNGU_DecodeToRGB565 (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 +	\
-							(coordX) * 2, (bufferWidth) - (imgWidth))
-
-// Expands selected image into a linear RGBA8 buffer. You need to specify context, image dimensions, 
-// destination address, stride in pixels and default alpha value, which is used if the source image 
-// doesn't have an alpha channel.
-int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride, PNGU_u8 default_alpha);
-
-// Macro for decoding an image inside a buffer at given coordinates.
-#define PNGU_DECODE_TO_COORDS_RGBA8(ctx,coordX,coordY,imgWidth,imgHeight,default_alpha,bufferWidth,bufferHeight,buffer)	\
-																											\
-		PNGU_DecodeToRGBA8 (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 +	\
-							(coordX) * 2, (bufferWidth) - (imgWidth), default_alpha)
-
-// Expands selected image into a 4x4 tiled RGB565 buffer. You need to specify context, image dimensions
-// and destination address.
-int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer);
-
-// Expands selected image into a 4x4 tiled RGB5A3 buffer. You need to specify context, image dimensions,
-// destination address and default alpha value, which is used if the source image doesn't have an alpha channel.
-int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha);
-
-// Expands selected image into a 4x4 tiled RGBA8 buffer. You need to specify context, image dimensions,
-// destination address and default alpha value, which is used if the source image doesn't have an alpha channel.
-int PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha);
-
-// Encodes an YCbYCr image in PNG format and stores it in the selected device or memory buffer. You need to 
-// specify context, image dimensions, destination address and stride in pixels (stride = buffer width - image width).
-int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride);
-
-// Macro for encoding an image stored into an YCbYCr buffer at given coordinates.
-#define PNGU_ENCODE_TO_COORDS_YCbYCr(ctx,coordX,coordY,imgWidth,imgHeight,bufferWidth,bufferHeight,buffer)	\
-																											\
-		PNGU_EncodeFromYCbYCr (ctx, imgWidth, imgHeight, ((void *) buffer) + (coordY) * (bufferWidth) * 2 +	\
-							(coordX) * 2, (bufferWidth) - (imgWidth))
-
-#ifdef __cplusplus
-	}
-#endif
-
-#endif
-
diff --git a/nand-loader/source/loader.c b/nand-loader/source/loader.c
index 9ab4e54..763f366 100644
--- a/nand-loader/source/loader.c
+++ b/nand-loader/source/loader.c
@@ -1,11 +1,13 @@
 #include <stdio.h>
 #include <string.h>
 #include <ogcsys.h>
+#include <ogc/lwp_watchdog.h>
 
 #include "config.h"
 #include "patches.h"
 #include "video.h"
 #include "wpad.h"
+#include "tools.h"
 
 /* DOL header structure */
 typedef struct {
@@ -41,6 +43,18 @@ void __Loader_SetLowMem(void)
 
 	/* Flush cache */
 	DCFlushRange((void *)(0x80000000), 0x3F00);
+
+	// Set the clock
+	settime(secs_to_ticks(time(NULL) - 946684800)); 
+	
+	// Remove 002 error (set to IOS 53)
+	*(u16 *)0x80003140 = 0x0035;
+	*(u16 *)0x80003142 = 0xffff;
+	*(u16 *)0x80003188 = 0x0035;
+	*(u16 *)0x8000318A = 0xffff;
+	
+	DCFlushRange((void*)0x80003140, 4);
+	DCFlushRange((void*)0x80003188, 4);
 }
 
 void __Loader_SetVMode(u64 tid)
@@ -115,6 +129,11 @@ void __Loader_SetVMode(u64 tid)
 		Video_Configure(vmode_ptr);
 		Video_Clear(COLOR_BLACK);
 	}
+	
+	// Anti-green screen fix
+    VIDEO_SetBlack(TRUE);
+    VIDEO_Flush();
+    VIDEO_WaitVSync();
 }
 
 
diff --git a/nand-loader/source/tools.c b/nand-loader/source/tools.c
new file mode 100644
index 0000000..b9f8808
--- /dev/null
+++ b/nand-loader/source/tools.c
@@ -0,0 +1,252 @@
+/*******************************************************************************
+ * tools.c
+ *
+ * Copyright (c) 2009 The Lemon Man
+ * Copyright (c) 2009 Nicksasa
+ * Copyright (c) 2009 WiiPower
+ *
+ * Distributed under the terms of the GNU General Public License (v2)
+ * See http://www.gnu.org/licenses/gpl-2.0.txt for more info.
+ *
+ * Description:
+ * -----------
+ *
+ ******************************************************************************/
+
+#include <gccore.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <wiiuse/wpad.h>
+
+#include "tools.h"
+
+void printheadline()
+{
+	int rows, cols;
+	CON_GetMetrics(&cols, &rows);
+
+	printf("TriiForce beta 7");
+	
+	char buf[64];
+	sprintf(buf, "IOS%u (Rev %u)\n", IOS_GetVersion(), IOS_GetRevision());
+	printf("\x1B[%d;%dH", 0, cols-strlen(buf)-1);	
+	printf(buf);
+}
+
+void set_highlight(bool highlight)
+{
+	if (highlight)
+	{
+		printf("\x1b[%u;%um", 47, false);
+		printf("\x1b[%u;%um", 30, false);
+	} else
+	{
+		printf("\x1b[%u;%um", 37, false);
+		printf("\x1b[%u;%um", 40, false);
+	}
+}
+
+void *allocate_memory(u32 size)
+{
+	return memalign(32, (size+31)&(~31) );
+}
+
+void Verify_Flags()
+{
+	if (Power_Flag)
+	{
+		WPAD_Shutdown();
+		STM_ShutdownToStandby();
+	}
+	if (Reset_Flag)
+	{
+		WPAD_Shutdown();
+		STM_RebootSystem();
+	}
+}
+
+
+void waitforbuttonpress(u32 *out, u32 *outGC)
+{
+	u32 pressed = 0;
+	u32 pressedGC = 0;
+
+	while (true)
+	{
+		Verify_Flags();
+		
+		WPAD_ScanPads();
+		pressed = WPAD_ButtonsDown(0);
+
+		PAD_ScanPads();
+		pressedGC = PAD_ButtonsDown(0);
+
+		if(pressed || pressedGC) 
+		{
+			if (pressedGC)
+			{
+				// Without waiting you can't select anything
+				usleep (20000);
+			}
+			if (out) *out = pressed;
+			if (outGC) *outGC = pressedGC;
+			return;
+		}
+	}
+}
+
+
+s32 read_file(char *filepath, u8 **buffer, u32 *filesize)
+{
+	s32 Fd;
+	int ret;
+
+	if (buffer == NULL)
+	{
+		printf("NULL Pointer\n");
+		return -1;
+	}
+
+	Fd = ISFS_Open(filepath, ISFS_OPEN_READ);
+	if (Fd < 0)
+	{
+		printf("ISFS_Open %s failed %d\n", filepath, Fd);
+		return Fd;
+	}
+
+	fstats *status;
+	status = allocate_memory(sizeof(fstats));
+	if (status == NULL)
+	{
+		printf("Out of memory for status\n");
+		return -1;
+	}
+	
+	ret = ISFS_GetFileStats(Fd, status);
+	if (ret < 0)
+	{
+		printf("ISFS_GetFileStats failed %d\n", ret);
+		ISFS_Close(Fd);
+		free(status);
+		return -1;
+	}
+	
+	*buffer = allocate_memory(status->file_length);
+	if (*buffer == NULL)
+	{
+		printf("Out of memory for buffer\n");
+		ISFS_Close(Fd);
+		free(status);
+		return -1;
+	}
+		
+	ret = ISFS_Read(Fd, *buffer, status->file_length);
+	if (ret < 0)
+	{
+		printf("ISFS_Read failed %d\n", ret);
+		ISFS_Close(Fd);
+		free(status);
+		free(*buffer);
+		return ret;
+	}
+	ISFS_Close(Fd);
+
+	*filesize = status->file_length;
+	free(status);
+
+	return 0;
+}
+
+s32 identify(u64 titleid, u32 *ios)
+{
+	char filepath[ISFS_MAXPATH] ATTRIBUTE_ALIGN(0x20);
+	u8 *tmdBuffer = NULL;
+	u32 tmdSize;
+	u8 *tikBuffer = NULL;
+	u32 tikSize;
+	u8 *certBuffer = NULL;
+	u32 certSize;
+	
+	int ret;
+
+	printf("Reading TMD...");
+	fflush(stdout);
+	
+	sprintf(filepath, "/title/%08x/%08x/content/title.tmd", TITLE_UPPER(titleid), TITLE_LOWER(titleid));
+	ret = read_file(filepath, &tmdBuffer, &tmdSize);
+	if (ret < 0)
+	{
+		printf("Reading TMD failed\n");
+		return ret;
+	}
+	printf("done\n");
+
+	*ios = (u32)(tmdBuffer[0x18b]);
+
+	printf("Reading ticket...");
+	fflush(stdout);
+
+	sprintf(filepath, "/ticket/%08x/%08x.tik", TITLE_UPPER(titleid), TITLE_LOWER(titleid));
+	ret = read_file(filepath, &tikBuffer, &tikSize);
+	if (ret < 0)
+	{
+		printf("Reading ticket failed\n");
+		free(tmdBuffer);
+		return ret;
+	}
+	printf("done\n");
+
+	printf("Reading certs...");
+	fflush(stdout);
+
+	sprintf(filepath, "/sys/cert.sys");
+	ret = read_file(filepath, &certBuffer, &certSize);
+	if (ret < 0)
+	{
+		printf("Reading certs failed\n");
+		free(tmdBuffer);
+		free(tikBuffer);
+		return ret;
+	}
+	printf("done\n");
+	
+	printf("ES_Identify...");
+	fflush(stdout);
+
+	ret = ES_Identify((signed_blob*)certBuffer, certSize, (signed_blob*)tmdBuffer, tmdSize, (signed_blob*)tikBuffer, tikSize, NULL);
+	if (ret < 0)
+	{
+		switch(ret)
+		{
+			case ES_EINVAL:
+				printf("Error! ES_Identify (ret = %d;) Data invalid!\n", ret);
+				break;
+			case ES_EALIGN:
+				printf("Error! ES_Identify (ret = %d;) Data not aligned!\n", ret);
+				break;
+			case ES_ENOTINIT:
+				printf("Error! ES_Identify (ret = %d;) ES not initialized!\n", ret);
+				break;
+			case ES_ENOMEM:
+				printf("Error! ES_Identify (ret = %d;) No memory!\n", ret);
+				break;
+			default:
+				printf("Error! ES_Identify (ret = %d)\n", ret);
+				break;
+		}
+		free(tmdBuffer);
+		free(tikBuffer);
+		free(certBuffer);
+		return ret;
+	}
+	printf("done\n");
+	
+	free(tmdBuffer);
+	free(tikBuffer);
+	free(certBuffer);
+	return 0;
+}
+
+
diff --git a/nand-loader/source/tools.h b/nand-loader/source/tools.h
new file mode 100644
index 0000000..b7532cc
--- /dev/null
+++ b/nand-loader/source/tools.h
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * tools.h
+ *
+ * Copyright (c) 2009 The Lemon Man
+ * Copyright (c) 2009 Nicksasa
+ * Copyright (c) 2009 WiiPower
+ *
+ * Distributed under the terms of the GNU General Public License (v2)
+ * See http://www.gnu.org/licenses/gpl-2.0.txt for more info.
+ *
+ * Description:
+ * -----------
+ *
+ ******************************************************************************/
+
+#define TITLE_UPPER(x)		((u32)((x) >> 32))
+#define TITLE_LOWER(x)		((u32)(x))
+#define TITLE_ID(x,y)		(((u64)(x) << 32) | (y))
+
+bool Power_Flag;
+bool Reset_Flag;
+
+void *allocate_memory(u32 size);
+s32 read_file(char *filepath, u8 **buffer, u32 *filesize);
+s32 identify(u64 titleid, u32 *ios);
+void set_highlight(bool highlight);
+void waitforbuttonpress(u32 *out, u32 *outGC);
+void printheadline();
+
+
+