[libpng16] Imported from libpng-1.6.0rc03.tar

[libpng16] Fixed palette_max API.
[libpng16] Bump version to 1.6.0rc03
2025-07-10 18:04:09 +02:00 · 2013-02-05 10:34:11 -06:00 · 2013-02-05 08:01:09 -06:00 · 2013-02-04 20:43:27 -06:00 · 2013-02-04 20:12:49 -06:00 · 2013-02-04 19:57:32 -06:00
80 changed files with 2888 additions and 3113 deletions
--- a/122
+++ b/122
@@ -1,5 +1,5 @@

-Libpng 1.6.0beta29 - September 4, 2012
+Libpng 1.6.0rc03 - February 5, 2013

 This is not intended to be a public release.  It will be replaced
 within a few weeks by a public version or by another test version.
@@ -9,20 +9,19 @@ Files available for download:
 Source files with LF line endings (for Unix/Linux) and with a
 "configure" script

-   1.6.0beta29.tar.xz (LZMA-compressed, recommended)
-   1.6.0beta29.tar.gz
-   1.6.0beta29.tar.bz2
+   1.6.0rc03.tar.xz (LZMA-compressed, recommended)
+   1.6.0rc03.tar.gz

 Source files with CRLF line endings (for Windows), without the
 "configure" script

-   lp160b29.7z  (LZMA-compressed, recommended)
-   lp160b29.zip
+   lp160r03.7z  (LZMA-compressed, recommended)
+   lp160r03.zip

 Other information:

-   1.6.0beta29-README.txt
-   1.6.0beta29-LICENSE.txt
+   1.6.0rc03-README.txt
+   1.6.0rc03-LICENSE.txt

 Changes since the last public release (1.5.7):

@@ -504,6 +503,113 @@ Version 1.6.0beta29 [September 4, 2012]
    part plus guessing a gAMA value requires code to pass selected RGB values
    through the profile.

+Version 1.6.0beta30 [October 24, 2012]
+  Changed ICC profile matrix/vector types to not depend on array type rules.
+    By the ANSI-C standard the new types should be identical to the previous
+    versions, and all known versions of gcc tested with the previous versions
+    except for GCC-4.2.1 work with this version.  The change makes the ANSI-C
+    rule that const applied to an array of elements applies instead to the
+    elements in the array moot by explicitly applying const to the base
+    elements of the png_icc_matrix and png_icc_vector types. The accidental
+    (harmless) 'const' previously applied to the parameters of two of the
+    functions have also been removed.
+  Added a work around for GCC 4.2 optimization bug.
+  Marked the broken (bad white point) original HP sRGB profiles correctly and
+    correct comments.
+  Added -DZ_SOLO to contrib/pngminim/*/makefile to work with zlib-1.2.7
+  Use /MDd for vstudio debug builds. Also added pngunkown to the vstudio
+    builds, fixed build errors and corrected a minor exit code error in
+    pngvalid if the 'touch' file name is invalid.
+  Add updated WARNING file to projects/vstudio from libpng 1.5/vstudio
+  Fixed build when using #define PNG_NO_READ_GAMMA in png_do_compose() in
+    pngrtran.c (Domani Hannes).
+
+Version 1.6.0beta31 [November 1, 2012]
+  Undid the erroneous change to vstudio/pngvalid build in libpng-1.6.0beta30.
+  Made pngvalid so that it will build outside the libpng source tree.
+  Made builds -DPNG_NO_READ_GAMMA compile (the unit tests still fail).
+  Made PNG_NO_READ_GAMMA switch off interfaces that depend on READ_GAMMA.
+    Prior to 1.6.0 switching off READ_GAMMA did unpredictable things to the
+    interfaces that use it (specifically, png_do_background in 1.4 would
+    simply display composite for grayscale images but do composition
+    with the incorrect arithmetic for color ones). In 1.6 the semantic
+    of -DPNG_NO_READ_GAMMA is changed to simply disable any interface that
+    depends on it; this obliges people who set it to consider whether they
+    really want it off if they happen to use any of the interfaces in
+    question (typically most users who disable it won't).
+  Fixed GUIDs in projects/vstudio. Some were duplicated or missing,
+    resulting in VS2010 having to update the files.
+  Removed non-working ICC profile support code that was mostly added to
+    libpng-1.6.0beta29 and beta30. There was too much code for too little
+    gain; implementing full ICC color correction may be desireable but is left
+    up to applications.
+
+Version 1.6.0beta32 [November 25, 2012]
+  Fixed an intermittent SEGV in pngstest due to an uninitialized array element.
+  Added the ability for contrib/libtests/makepng.c to make a PNG with just one
+    color. This is useful for debugging pngstest color inaccuracy reports.
+  Fixed error checking in the simplified write API (Olaf van der Spek)
+  Made png_user_version_check() ok to use with libpng version 1.10.x and later.
+
+Version 1.6.0beta33 [December 15, 2012]
+  Fixed typo in png.c (PNG_SET_CHUNK_MALLOC_MAX should be PNG_CHUNK_MALLOC_MAX)
+    that causes the MALLOC_MAX limit not to work (John Bowler)
+  Change png_warning() to png_app_error() in pngwrite.c and comment the
+    fall-through condition.
+  Change png_warning() to png_app_warning() in png_write_tRNS().
+  Rearranged the ARM-NEON optimizations: Isolated the machine specific code
+    to the hardware subdirectory and added comments to pngrutil.c so that
+    implementors of other optimizations know what to do.
+  Fixed cases of unquoted DESTDIR in Makefile.am
+  Rebuilt Makefile.in, etc., with autoconf-2.69 and automake-1.12.5.
+
+Version 1.6.0beta34 [December 19, 2012]
+  Cleaned up whitespace in the synopsis portion of the manpage "libpng.3"
+  Disassembled the version number in scripts/options.awk (necessary for
+    building on SunOs).
+
+Version 1.6.0beta35 [December 23, 2012]
+  Made default Zlib compression settings be configurable. This adds #defines to
+    pnglibconf.h to control the defaults.
+  Fixed Windows build issues, enabled ARM compilation. Various warnings issued
+    by earlier versions of GCC fixed for Cygwin and Min/GW (which both use old
+    GCCs.) ARM support is enabled by default in zlib.props (unsupported by
+    Microsoft) and ARM compilation is made possible by deleting the check for
+    x86. The test programs cannot be run because they are not signed.
+
+Version 1.6.0beta36 [January 2, 2013]
+  Discontinued distributing libpng-1.x.x.tar.bz2.
+  Discontinued distributing libpng-1.7.0-1.6.0-diff.txt and similar.
+  Rebuilt configure with autoconf-2.69 (inadvertently not done in beta33)
+  Fixed 'make distcheck' on SUN OS - libpng.so was not being removed
+
+Version 1.6.0beta37 [January 10, 2013]
+  Fixed conceivable but difficult to repro overflow. Also added two test
+    programs to generate and test a PNG which should have the problem.
+
+Version 1.6.0beta39 [January 19, 2013]
+  Again corrected attempt at overflow detection in png_set_unknown_chunks().
+  Added overflow detection in png_set_sPLT() and png_set_text_2().
+
+Version 1.6.0beta40 [January 20, 2013]
+  Use consistent handling of overflows in text, sPLT and unknown png_set_* APIs
+
+Version 1.6.0rc01 [January 26, 2013]
+  No changes.
+
+Version 1.6.0rc02 [February 4, 2013]
+  Added png_get_palette_max() function.
+
+Version 1.6.0rc03 [February 5, 2013]
+  Fixed the png_get_palette_max API.
+
+
+  ===========================================================================
+                       NOTICE November 17, 2012:
+     The location of the git repository at SourceForge has changed.
+               Visit http://libpng.sf.net/ for details.
+  ===========================================================================
+
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
--- a/109
+++ b/109
@@ -3779,7 +3779,8 @@ Version 1.5.7 [December 15, 2011]

 Version 1.6.0beta01 [December 15, 2011]
  Removed machine-generated configure files from the GIT repository (they will
-    continue to appear in the tarball distributions).
+    continue to appear in the tarball distributions and in the libpng15 and
+    earlier GIT branches).
  Restored the new 'simplified' API, which was started in libpng-1.5.7beta02
    but later deleted from libpng-1.5.7beta05.
  Added example programs for the new 'simplified' API.
@@ -4256,6 +4257,112 @@ Version 1.6.0beta29 [September 4, 2012]
    part plus guessing a gAMA value requires code to pass selected RGB values
    through the profile.

+Version 1.6.0beta30 [October 24, 2012]
+  Changed ICC profile matrix/vector types to not depend on array type rules.
+    By the ANSI-C standard the new types should be identical to the previous
+    versions, and all known versions of gcc tested with the previous versions
+    except for GCC-4.2.1 work with this version.  The change makes the ANSI-C
+    rule that const applied to an array of elements applies instead to the
+    elements in the array moot by explicitly applying const to the base
+    elements of the png_icc_matrix and png_icc_vector types. The accidental
+    (harmless) 'const' previously applied to the parameters of two of the
+    functions have also been removed.
+  Added a work around for GCC 4.2 optimization bug.
+  Marked the broken (bad white point) original HP sRGB profiles correctly and
+    correct comments.
+  Added -DZ_SOLO to contrib/pngminim/*/makefile to work with zlib-1.2.7
+  Use /MDd for vstudio debug builds. Also added pngunkown to the vstudio
+    builds, fixed build errors and corrected a minor exit code error in
+    pngvalid if the 'touch' file name is invalid.
+  Add updated WARNING file to projects/vstudio from libpng 1.5/vstudio
+  Fixed build when using #define PNG_NO_READ_GAMMA in png_do_compose() in
+    pngrtran.c (Domani Hannes).
+
+Version 1.6.0beta31 [November 1, 2012]
+  Undid the erroneous change to vstudio/pngvalid build in libpng-1.6.0beta30.
+  Made pngvalid so that it will build outside the libpng source tree.
+  Made builds -DPNG_NO_READ_GAMMA compile (the unit tests still fail).
+  Made PNG_NO_READ_GAMMA switch off interfaces that depend on READ_GAMMA.
+    Prior to 1.6.0 switching off READ_GAMMA did unpredictable things to the
+    interfaces that use it (specifically, png_do_background in 1.4 would
+    simply display composite for grayscale images but do composition
+    with the incorrect arithmetic for color ones). In 1.6 the semantic
+    of -DPNG_NO_READ_GAMMA is changed to simply disable any interface that
+    depends on it; this obliges people who set it to consider whether they
+    really want it off if they happen to use any of the interfaces in
+    question (typically most users who disable it won't).
+  Fixed GUIDs in projects/vstudio. Some were duplicated or missing,
+    resulting in VS2010 having to update the files.
+  Removed non-working ICC profile support code that was mostly added to
+    libpng-1.6.0beta29 and beta30. There was too much code for too little
+    gain; implementing full ICC color correction may be desireable but is left
+    up to applications.
+
+Version 1.6.0beta32 [November 25, 2012]
+  Fixed an intermittent SEGV in pngstest due to an uninitialized array element.
+  Added the ability for contrib/libtests/makepng.c to make a PNG with just one
+    color. This is useful for debugging pngstest color inaccuracy reports.
+  Fixed error checking in the simplified write API (Olaf van der Spek)
+  Made png_user_version_check() ok to use with libpng version 1.10.x and later.
+
+Version 1.6.0beta33 [December 15, 2012]
+  Fixed typo in png.c (PNG_SET_CHUNK_MALLOC_MAX should be PNG_CHUNK_MALLOC_MAX)
+    that causes the MALLOC_MAX limit not to work (John Bowler)
+  Change png_warning() to png_app_error() in pngwrite.c and comment the
+    fall-through condition.
+  Change png_warning() to png_app_warning() in png_write_tRNS().
+  Rearranged the ARM-NEON optimizations: Isolated the machine specific code
+    to the hardware subdirectory and added comments to pngrutil.c so that
+    implementors of other optimizations know what to do.
+  Fixed cases of unquoted DESTDIR in Makefile.am
+  Rebuilt Makefile.in, etc., with autoconf-2.69 and automake-1.12.5.
+
+Version 1.6.0beta34 [December 19, 2012]
+  Cleaned up whitespace in the synopsis portion of the manpage "libpng.3"
+  Disassembled the version number in scripts/options.awk (necessary for
+    building on SunOs).
+
+Version 1.6.0beta35 [December 23, 2012]
+  Made default Zlib compression settings be configurable. This adds #defines to
+    pnglibconf.h to control the defaults.
+  Fixed Windows build issues, enabled ARM compilation. Various warnings issued
+    by earlier versions of GCC fixed for Cygwin and Min/GW (which both use old
+    GCCs.) ARM support is enabled by default in zlib.props (unsupported by
+    Microsoft) and ARM compilation is made possible by deleting the check for
+    x86. The test programs cannot be run because they are not signed.
+
+Version 1.6.0beta36 [January 2, 2013]
+  Discontinued distributing libpng-1.x.x.tar.bz2.
+  Discontinued distributing libpng-1.7.0-1.6.0-diff.txt and similar.
+  Rebuilt configure with autoconf-2.69 (inadvertently not done in beta33)
+  Fixed 'make distcheck' on SUN OS - libpng.so was not being removed
+
+Version 1.6.0beta37 [January 10, 2013]
+  Fixed conceivable but difficult to repro overflow. Also added two test
+    programs to generate and test a PNG which should have the problem.
+
+Version 1.6.0beta39 [January 19, 2013]
+  Again corrected attempt at overflow detection in png_set_unknown_chunks().
+  Added overflow detection in png_set_sPLT() and png_set_text_2().
+
+Version 1.6.0beta40 [January 20, 2013]
+  Use consistent handling of overflows in text, sPLT and unknown png_set_* APIs
+
+Version 1.6.0rc01 [January 26, 2013]
+  No changes.
+
+Version 1.6.0rc02 [February 4, 2013]
+  Added png_get_palette_max() function.
+
+Version 1.6.0rc03 [February 5, 2013]
+  Fixed the png_get_palette_max API.
+
+  ===========================================================================
+                       NOTICE November 17, 2012:
+     The location of the git repository at SourceForge has changed.
+               Visit http://libpng.sf.net/ for details.
+  ===========================================================================
+
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -260,7 +260,7 @@ endif(NOT WIN32 OR CYGWIN OR MINGW)
 # SET UP LINKS
 if(PNG_SHARED)
  set_target_properties(${PNG_LIB_NAME} PROPERTIES
-#   VERSION 16.${PNGLIB_RELEASE}.1.6.0beta29
+#   VERSION 16.${PNGLIB_RELEASE}.1.6.0rc03
    VERSION 16.${PNGLIB_RELEASE}.0
    SOVERSION 16
    CLEAN_DIRECT_OUTPUT 1)
--- a/4
+++ b/4
@@ -10,7 +10,7 @@ this sentence.

 This code is released under the libpng license.

-libpng versions 1.2.6, August 15, 2004, through 1.6.0beta29, September 4, 2012, are
+libpng versions 1.2.6, August 15, 2004, through 1.6.0rc03, February 5, 2013, are
 Copyright (c) 2004, 2006-2012 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
@@ -108,4 +108,4 @@ certification mark of the Open Source Initiative.

 Glenn Randers-Pehrson
 glennrp at users.sourceforge.net
-September 4, 2012
+February 5, 2013
--- a/Makefile.am
+++ b/Makefile.am
@@ -43,7 +43,8 @@ libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = png.c pngerror.c\
 	png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngusr.dfa

 if PNG_ARM_NEON
-libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += arm/filter_neon.S
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += arm/arm_init.c\
+	arm/filter_neon.S
 endif

 nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
@@ -236,22 +237,24 @@ dist-hook:

 # install the .../include headers as links to the new ones
 install-data-hook:
-	cd $(DESTDIR)$(includedir); rm -f png.h pngconf.h pnglibconf.h
-	cd $(DESTDIR)$(includedir); $(LN_S) $(PNGLIB_BASENAME)/png.h png.h
-	cd $(DESTDIR)$(includedir); $(LN_S) $(PNGLIB_BASENAME)/pngconf.h \
+	cd '$(DESTDIR)$(includedir)'; rm -f png.h pngconf.h pnglibconf.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/png.h png.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/pngconf.h \
 		pngconf.h
-	cd $(DESTDIR)$(includedir); $(LN_S) $(PNGLIB_BASENAME)/pnglibconf.h \
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/pnglibconf.h \
 		pnglibconf.h
-	cd $(DESTDIR)$(pkgconfigdir); rm -f libpng.pc
-	cd $(DESTDIR)$(pkgconfigdir); $(LN_S) $(PNGLIB_BASENAME).pc libpng.pc
+	cd '$(DESTDIR)$(pkgconfigdir)'; rm -f libpng.pc
+	cd '$(DESTDIR)$(pkgconfigdir)'; $(LN_S) $(PNGLIB_BASENAME).pc libpng.pc

 # do evil things to libpng to cause libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@ to be used
 install-exec-hook:
-	cd $(DESTDIR)$(bindir); rm -f libpng-config
-	cd $(DESTDIR)$(bindir); $(LN_S) $(PNGLIB_BASENAME)-config libpng-config
+	cd '$(DESTDIR)$(bindir)'; rm -f libpng-config
+	cd '$(DESTDIR)$(bindir)';\
+	   $(LN_S) $(PNGLIB_BASENAME)-config libpng-config
 	@set -x;\
-	cd $(DESTDIR)$(libdir);\
-	for ext in a la so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@ sl dylib dll.a; do\
+	cd '$(DESTDIR)$(libdir)';\
+	for ext in a la so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@\
+	   sl dylib dll.a; do\
 		rm -f libpng.$$ext;\
                if test -f $(PNGLIB_BASENAME).$$ext; then\
                       $(LN_S) $(PNGLIB_BASENAME).$$ext libpng.$$ext;\
@@ -259,9 +262,13 @@ install-exec-hook:
 	done

 uninstall-hook:
-	cd $(DESTDIR)$(includedir); rm -f png.h pngconf.h pnglibconf.h
-	rm -f $(DESTDIR)$(pkgconfigdir)/libpng.pc
-	rm -f $(DESTDIR)$(bindir)/libpng-config
-	rm -f $(DESTDIR)$(libdir)/libpng.a
-	rm -f $(DESTDIR)$(libdir)/libpng.la
-	rm -f $(DESTDIR)$(libdir)/libpng.dll.a
+	cd '$(DESTDIR)$(includedir)'; rm -f png.h pngconf.h pnglibconf.h
+	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
+	rm -f '$(DESTDIR)$(bindir)/libpng-config'
+	rm -f '$(DESTDIR)$(libdir)/libpng.a'
+	rm -f '$(DESTDIR)$(libdir)/libpng.la'
+	rm -f '$(DESTDIR)$(libdir)/libpng.so'
+	rm -f '$(DESTDIR)$(libdir)/libpng.so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@'
+	rm -f '$(DESTDIR)$(libdir)/libpng.sl'
+	rm -f '$(DESTDIR)$(libdir)/libpng.dylib'
+	rm -f '$(DESTDIR)$(libdir)/libpng.dll.a'
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-README for libpng version 1.6.0beta29 - September 4, 2012 (shared library 16.0)
+README for libpng version 1.6.0rc03 - February 5, 2013 (shared library 16.0)
 See the note about version numbers near the top of png.h

 See INSTALL for instructions on how to install libpng.
--- a/arm/arm_init.c
+++ b/arm/arm_init.c
@@ -0,0 +1,86 @@
+
+/* arm_init.c - NEON optimised filter functions
+ *
+ * Copyright (c) 2012 Glenn Randers-Pehrson
+ * Written by Mans Rullgard, 2011.
+ * Last changed in libpng 1.5.14 [(PENDING RELEASE)]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+#include "../pngpriv.h"
+
+/* __arm__ is defined by GCC, MSVC defines _M_ARM to the ARM version number */
+#if defined __linux__ && defined __arm__
+#include <stdio.h>
+#include <elf.h>
+#include <asm/hwcap.h>
+
+static int png_have_hwcap(unsigned cap)
+{
+   FILE *f = fopen("/proc/self/auxv", "r");
+   Elf32_auxv_t aux;
+   int have_cap = 0;
+
+   if (!f)
+      return 0;
+
+   while (fread(&aux, sizeof(aux), 1, f) > 0)
+   {
+      if (aux.a_type == AT_HWCAP &&
+          aux.a_un.a_val & cap)
+      {
+         have_cap = 1;
+         break;
+      }
+   }
+
+   fclose(f);
+
+   return have_cap;
+}
+#endif /* __linux__ && __arm__ */
+
+void
+png_init_filter_functions_neon(png_structp pp, unsigned int bpp)
+{
+#ifdef __arm__
+#ifdef __linux__
+   if (!png_have_hwcap(HWCAP_NEON))
+      return;
+#endif
+
+   /* IMPORTANT: any new external functions used here must be declared using
+    * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
+    * 'prefix' option to configure works:
+    *
+    *    ./configure --with-libpng-prefix=foobar_
+    *
+    * Verify you have got this right by running the above command, doing a build
+    * and examining pngprefix.h; it must contain a #define for every external
+    * function you add.  (Notice that this happens automatically for the
+    * initialization function.)
+    */
+   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_neon;
+
+   if (bpp == 3)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_neon;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_neon;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
+         png_read_filter_row_paeth3_neon;
+   }
+
+   else if (bpp == 4)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_neon;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_neon;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
+          png_read_filter_row_paeth4_neon;
+   }
+#else
+   PNG_UNUSED(pp)
+   PNG_UNUSED(bpp)
+#endif
+}
--- a/arm/filter_neon.S
+++ b/arm/filter_neon.S
@@ -3,12 +3,14 @@
 *
 * Copyright (c) 2011 Glenn Randers-Pehrson
 * Written by Mans Rullgard, 2011.
+ * Last changed in libpng 1.5.7 [December 15, 2011]
 *
 * This code is released under the libpng license.
 * For conditions of distribution and use, see the disclaimer
 * and license in png.h
 */

+#ifdef __arm__
 #if defined(__linux__) && defined(__ELF__)
 .section .note.GNU-stack,"",%progbits /* mark stack as non-executable */
 #endif
@@ -223,3 +225,4 @@ func    png_read_filter_row_paeth3_neon, export=1

        pop             {r4,pc}
 endfunc
+#endif
--- a/configure.ac
+++ b/configure.ac
@@ -18,7 +18,7 @@ AC_PREREQ([2.68])

 dnl Version number stuff here:

-AC_INIT([libpng],[1.6.0beta29],[png-mng-implement@lists.sourceforge.net])
+AC_INIT([libpng],[1.6.0rc03],[png-mng-implement@lists.sourceforge.net])
 AC_CONFIG_MACRO_DIR([scripts])

 # libpng does not follow GNU file name conventions (hence 'foreign')
@@ -26,7 +26,7 @@ AC_CONFIG_MACRO_DIR([scripts])
 # silent-rules requires automake 1.11 or later
 # dist-xz requires automake 1.11 or later
 # 1.12.2 fixes a security issue in 1.11.2 and 1.12.1
-AM_INIT_AUTOMAKE([1.12.2 foreign dist-xz dist-bzip2 color-tests silent-rules])
+AM_INIT_AUTOMAKE([1.12.2 foreign dist-xz color-tests silent-rules])
 # was:
 # AM_INIT_AUTOMAKE
 AM_MAINTAINER_MODE
@@ -37,7 +37,7 @@ dnl automake, so the following is not necessary (and is not defined anyway):
 dnl AM_PREREQ([1.11.2])
 dnl stop configure from automagically running automake

-PNGLIB_VERSION=1.6.0beta29
+PNGLIB_VERSION=1.6.0rc03
 PNGLIB_MAJOR=1
 PNGLIB_MINOR=6
 PNGLIB_RELEASE=0
@@ -241,8 +241,11 @@ AC_SUBST([AM_CCASFLAGS], [-Wa,--noexecstack])
 AC_ARG_ENABLE([arm-neon],
   AS_HELP_STRING([[[--enable-arm-neon]]], [Enable ARM NEON optimizations]),
   [if test "${enableval}" = "yes"; then
-      AC_DEFINE([PNG_ARM_NEON], [1], [Enable ARM NEON optimizations])
-      AC_DEFINE([PNG_ALIGNED_MEMORY_SUPPORTED], [1], [Align row buffers])
+      AC_DEFINE([PNG_FILTER_OPTIMIZATIONS],
+                [png_init_filter_functions_neon],
+                [ARM NEON filter initialization function])
+      AC_DEFINE([PNG_ALIGNED_MEMORY_SUPPORTED], [1],
+                [Align row buffers])
    fi])
 AM_CONDITIONAL([PNG_ARM_NEON], [test "${enable_arm_neon:-no}" = yes])

--- a/contrib/examples/pngpixel.c
+++ b/contrib/examples/pngpixel.c
@@ -273,7 +273,7 @@ int main(int argc, const char **argv)
                           ystep = xstep = 1;
                        }

-                        /* To find the pixel loop over 'py' for each pass
+                        /* To find the pixel, loop over 'py' for each pass
                         * reading a row and then checking to see if it
                         * contains the pixel.
                         */
@@ -283,12 +283,13 @@ int main(int argc, const char **argv)

                           /* png_read_row takes two pointers.  When libpng
                            * handles the interlace the first is filled in
-                            * pixel-by-pixel, the second receives the same
+                            * pixel-by-pixel, and the second receives the same
                            * pixels but they are replicated across the
                            * unwritten pixels so far for each pass.  When we
                            * do the interlace, however, they just contain
                            * the pixels from the interlace pass - giving
-                            * both is wasteful and pointless.
+                            * both is wasteful and pointless, so we pass a
+                            * NULL pointer.
                            */
                           png_read_row(png_ptr, row_tmp, NULL);

@@ -326,7 +327,7 @@ int main(int argc, const char **argv)
               else
               {
                  /* Else libpng has raised an error.  An error message has
-                   * already been output, it is only necessary to clean up
+                   * already been output, so it is only necessary to clean up
                   * locally allocated data:
                   */
                  if (row != NULL)
--- a/contrib/libtests/fakepng.c
+++ b/contrib/libtests/fakepng.c
@@ -0,0 +1,57 @@
+/* Fake a PNG - just write it out directly. */
+#include <stdio.h>
+#include <zlib.h> /* for crc32 */
+
+void
+put_uLong(uLong val)
+{
+   putchar(val >> 24);
+   putchar(val >> 16);
+   putchar(val >>  8);
+   putchar(val >>  0);
+}
+
+void
+put_chunk(const unsigned char *chunk, uInt length)
+{
+   uLong crc;
+
+   put_uLong(length-4); /* Exclude the tag */
+
+   fwrite(chunk, length, 1, stdout);
+
+   crc = crc32(0, Z_NULL, 0);
+   put_uLong(crc32(crc, chunk, length));
+}
+
+const unsigned char signature[] =
+{
+   137, 80, 78, 71, 13, 10, 26, 10
+};
+
+const unsigned char IHDR[] =
+{
+   73, 72, 68, 82, /* IHDR */
+   0, 0, 0, 1, /* width */
+   0, 0, 0, 1, /* height */
+   1, /* bit depth */
+   0, /* color type: greyscale */
+   0, /* compression method */
+   0, /* filter method */
+   0  /* interlace method: none */
+};
+
+const unsigned char unknown[] =
+{
+   'u', 'n', 'K', 'n' /* "unKn" - private safe to copy */
+};
+
+int
+main(void)
+{
+   fwrite(signature, sizeof signature, 1, stdout);
+   put_chunk(IHDR, sizeof IHDR);
+
+   for(;;)
+      put_chunk(unknown, sizeof unknown);
+}
--- a/contrib/libtests/gentests.sh
+++ b/contrib/libtests/gentests.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright (c) 2012 John Cunningham Bowler
+# Copyright (c) 2013 John Cunningham Bowler
 #
 # Last changed in libpng 1.6.0 [(PENDING RELEASE)]
 #
--- a/contrib/libtests/makepng.c
+++ b/contrib/libtests/makepng.c
@@ -1,6 +1,6 @@
 /* makepng.c
 *
- * Copyright (c) 2012 John Cunningham Bowler
+ * Copyright (c) 2013 John Cunningham Bowler
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
 *
@@ -10,7 +10,8 @@
 *
 * Make a test PNG image.  The arguments are as follows:
 *
- *  makepng [--sRGB|--linear|--1.8] color-type bit-depth [file-name]
+ *  makepng [--sRGB|--linear|--1.8] [--color=<color>] color-type bit-depth \
+ *      [file-name]
 *
 * The color-type may be numeric (and must match the numbers used by the PNG
 * specification) or one of the format names listed below.  The bit-depth is the
@@ -23,7 +24,8 @@
 * approximately value^(1/1.45) to the color values and so a gAMA chunk of 65909
 * is written (1.45/2.2).
 *
- * The image data is generated internally.  The images used are as follows:
+ * The image data is generated internally.  Unless --color is given the images
+ * used are as follows:
 *
 * 1 channel: a square image with a diamond, the least luminous colors are on
 *    the edge of the image, the most luminous in the center.
@@ -58,9 +60,14 @@
 * 16 bits:           256x256
 * More than 16 bits: 1024x1024
 *
- * Row filtering is turned off (the 'none' filter is used on every row) and  the
+ * Row filtering is turned off (the 'none' filter is used on every row) and the
 * images are not interlaced.
 *
+ * If --color is given then the whole image has that color, color-mapped images
+ * will have exactly one palette entry and all image files with be 16x16 in
+ * size.  The color value is 1 to 4 decimal numbers as appropriate for the color
+ * type.
+ *
 * If file-name is given then the PNG is written to that file, else it is
 * written to stdout.  Notice that stdout is not supported on systems where, by
 * default, it assumes text output; this program makes no attempt to change the
@@ -128,18 +135,24 @@ pixel_depth_of_type(int color_type, int bit_depth)
 }

 static unsigned int
-image_size_of_type(int color_type, int bit_depth)
+image_size_of_type(int color_type, int bit_depth, unsigned int *colors)
 {
-   int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
-
-   if (pixel_depth < 8)
-      return 64;
-
-   else if (pixel_depth > 16)
-      return 1024;
+   if (*colors)
+      return 16;

   else
-      return 256;
+   {
+      int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
+
+      if (pixel_depth < 8)
+         return 64;
+
+      else if (pixel_depth > 16)
+         return 1024;
+
+      else
+         return 256;
+   }
 }

 static void
@@ -155,7 +168,7 @@ set_color(png_colorp color, png_bytep trans, unsigned int red,

 static int
 generate_palette(png_colorp palette, png_bytep trans, int bit_depth,
-   png_const_bytep gamma_table)
+   png_const_bytep gamma_table, unsigned int *colors)
 {
   /*
    * 1-bit: entry 0 is transparent-red, entry 1 is opaque-white
@@ -166,39 +179,69 @@ generate_palette(png_colorp palette, png_bytep trans, int bit_depth,
    * 4-bit: the 16 combinations of the 2-bit case
    * 8-bit: the 256 combinations of the 4-bit case
    */
-   if (bit_depth == 1)
+   switch (colors[0])
   {
-      set_color(palette+0, trans+0, 255, 0, 0, 0, gamma_table);
-      set_color(palette+1, trans+1, 255, 255, 255, 255, gamma_table);
-      return 2;
-   }
+      default:
+         fprintf(stderr, "makepng: --colors=...: invalid count %u\n",
+            colors[0]);
+         exit(1);

-   else
-   {
-      unsigned int size = 1U << (bit_depth/2); /* 2, 4 or 16 */
-      unsigned int x, y, ip;
-
-      for (x=0; x<size; ++x) for (y=0; y<size; ++y)
-      {
-         ip = x + (size * y);
-
-         /* size is at most 16, so the scaled value below fits in 16 bits */
-#        define interp(pos, c1, c2) ((pos * c1) + ((size-pos) * c2))
-#        define xyinterp(x, y, c1, c2, c3, c4) (((size * size / 2) +\
-            (interp(x, c1, c2) * y + (size-y) * interp(x, c3, c4))) /\
-            (size*size))
-
-         set_color(palette+ip, trans+ip,
-            /* color:    green, red,blue,white */
-            xyinterp(x, y,   0, 255,   0, 255),
-            xyinterp(x, y, 255,   0,   0, 255),
-            xyinterp(x, y,   0,   0, 255, 255),
-            /* alpha:        0, 102, 204, 255) */
-            xyinterp(x, y,   0, 102, 204, 255),
+      case 1:
+         set_color(palette+0, trans+0, colors[1], colors[1], colors[1], 255,
            gamma_table);
-      }
+         return 1;

-      return ip+1;
+      case 2:
+         set_color(palette+0, trans+0, colors[1], colors[1], colors[1],
+            colors[2], gamma_table);
+         return 1;
+
+      case 3:
+         set_color(palette+0, trans+0, colors[1], colors[2], colors[3], 255,
+            gamma_table);
+         return 1;
+
+      case 4:
+         set_color(palette+0, trans+0, colors[1], colors[2], colors[3],
+            colors[4], gamma_table);
+         return 1;
+
+      case 0:
+         if (bit_depth == 1)
+         {
+            set_color(palette+0, trans+0, 255, 0, 0, 0, gamma_table);
+            set_color(palette+1, trans+1, 255, 255, 255, 255, gamma_table);
+            return 2;
+         }
+
+         else
+         {
+            unsigned int size = 1U << (bit_depth/2); /* 2, 4 or 16 */
+            unsigned int x, y, ip;
+
+            for (x=0; x<size; ++x) for (y=0; y<size; ++y)
+            {
+               ip = x + (size * y);
+
+               /* size is at most 16, so the scaled value below fits in 16 bits
+                */
+#              define interp(pos, c1, c2) ((pos * c1) + ((size-pos) * c2))
+#              define xyinterp(x, y, c1, c2, c3, c4) (((size * size / 2) +\
+                  (interp(x, c1, c2) * y + (size-y) * interp(x, c3, c4))) /\
+                  (size*size))
+
+               set_color(palette+ip, trans+ip,
+                  /* color:    green, red,blue,white */
+                  xyinterp(x, y,   0, 255,   0, 255),
+                  xyinterp(x, y, 255,   0,   0, 255),
+                  xyinterp(x, y,   0,   0, 255, 255),
+                  /* alpha:        0, 102, 204, 255) */
+                  xyinterp(x, y,   0, 102, 204, 255),
+                  gamma_table);
+            }
+
+            return ip+1;
+         }
   }
 }

@@ -208,7 +251,7 @@ set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,
 {
   unsigned int mask = (1U << bit_depth)-1;

-   x *= bit_depth;  /* Maxium x is 4*1024, maxium bit_depth is 16 */
+   x *= bit_depth;  /* Maximum x is 4*1024, maximum bit_depth is 16 */

   if (value <= mask)
   {
@@ -265,12 +308,13 @@ set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,

 static void
 generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,
-   int bit_depth, png_const_bytep gamma_table, double conv)
+   int bit_depth, png_const_bytep gamma_table, double conv,
+   unsigned int *colors)
 {
-   png_uint_32 size_max = image_size_of_type(color_type, bit_depth)-1;
+   png_uint_32 size_max = image_size_of_type(color_type, bit_depth, colors)-1;
   png_uint_32 depth_max = (1U << bit_depth)-1; /* up to 65536 */

-   switch (channels_of_type(color_type))
+   if (colors[0] == 0) switch (channels_of_type(color_type))
   {
   /* 1 channel: a square image with a diamond, the least luminous colors are on
    *    the edge of the image, the most luminous in the center.
@@ -390,6 +434,98 @@ generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,
         fprintf(stderr, "makepng: internal bad channel count\n");
         exit(2);
   }
+
+   else if (color_type & PNG_COLOR_MASK_PALETTE)
+   {
+      /* Palette with fixed color: the image rows are all 0 and the image width
+       * is 16.
+       */
+      memset(row, rowbytes, 0);
+   }
+
+   else if (colors[0] == channels_of_type(color_type))
+      switch (channels_of_type(color_type))
+      {
+         case 1:
+            {
+               const png_uint_32 luma = colors[1];
+               png_uint_32 x;
+
+               for (x=0; x<=size_max; ++x)
+                  set_value(row, rowbytes, x, bit_depth, luma, gamma_table,
+                     conv);
+            }
+            break;
+
+         case 2:
+            {
+               const png_uint_32 luma = colors[1];
+               const png_uint_32 alpha = colors[2];
+               png_uint_32 x;
+
+               for (x=0; x<size_max; ++x)
+               {
+                  set_value(row, rowbytes, 2*x, bit_depth, luma, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 2*x+1, bit_depth, alpha, gamma_table,
+                     conv);
+               }
+            }
+            break;
+
+         case 3:
+            {
+               const png_uint_32 red = colors[1];
+               const png_uint_32 green = colors[2];
+               const png_uint_32 blue = colors[3];
+               png_uint_32 x;
+
+               for (x=0; x<=size_max; ++x)
+               {
+                  set_value(row, rowbytes, 3*x+0, bit_depth, red, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 3*x+1, bit_depth, green, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 3*x+2, bit_depth, blue, gamma_table,
+                     conv);
+               }
+            }
+            break;
+
+         case 4:
+            {
+               const png_uint_32 red = colors[1];
+               const png_uint_32 green = colors[2];
+               const png_uint_32 blue = colors[3];
+               const png_uint_32 alpha = colors[4];
+               png_uint_32 x;
+
+               for (x=0; x<=size_max; ++x)
+               {
+                  set_value(row, rowbytes, 4*x+0, bit_depth, red, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 4*x+1, bit_depth, green, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 4*x+2, bit_depth, blue, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 4*x+3, bit_depth, alpha, gamma_table,
+                     conv);
+               }
+            }
+         break;
+
+         default:
+            fprintf(stderr, "makepng: internal bad channel count\n");
+            exit(2);
+      }
+
+   else
+   {
+      fprintf(stderr,
+         "makepng: --color: count(%u) does not match channels(%u)\n",
+         colors[0], channels_of_type(color_type));
+      exit(1);
+   }
 }


@@ -418,7 +554,7 @@ makepng_error(png_structp png_ptr, png_const_charp message)
 static int /* 0 on success, else an error code */
 write_png(const char **name, FILE *fp, int color_type, int bit_depth,
   volatile png_fixed_point gamma, chunk_insert * volatile insert,
-   unsigned int filters)
+   unsigned int filters, unsigned int *colors)
 {
   png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
      name, makepng_error, makepng_warning);
@@ -452,7 +588,7 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
      png_error(png_ptr, "OOM allocating info structure");

   {
-      unsigned int size = image_size_of_type(color_type, bit_depth);
+      unsigned int size = image_size_of_type(color_type, bit_depth, colors);
      png_fixed_point real_gamma = 45455; /* For sRGB */
      png_byte gamma_table[256];
      double conv;
@@ -504,7 +640,8 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
         png_color palette[256];
         png_byte trans[256];

-         npalette = generate_palette(palette, trans, bit_depth, gamma_table);
+         npalette = generate_palette(palette, trans, bit_depth, gamma_table,
+            colors);
         png_set_PLTE(png_ptr, info_ptr, palette, npalette);
         png_set_tRNS(png_ptr, info_ptr, trans, npalette-1,
            NULL/*transparent color*/);
@@ -561,7 +698,7 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
            for (y=0; y<size; ++y)
            {
               generate_row(row, rowbytes, y, color_type, bit_depth,
-                  gamma_table, conv);
+                  gamma_table, conv, colors);
               png_write_row(png_ptr, row);
            }
         }
@@ -1094,6 +1231,48 @@ find_insert(png_const_charp what, png_charp param)
   return NULL;
 }

+/* This is a not-very-good parser for a sequence of numbers (including 0).  It
+ * doesn't accept some apparently valid things, but it accepts all the sensible
+ * combinations.
+ */
+static void
+parse_color(char *arg, unsigned int *colors)
+{
+   unsigned int ncolors = 0;
+
+   while (*arg && ncolors < 4)
+   {
+      char *ep = arg;
+
+      unsigned long ul = strtoul(arg, &ep, 0);
+
+      if (ul > 65535)
+      {
+         fprintf(stderr, "makepng --color=...'%s': too big\n", arg);
+         exit(1);
+      }
+
+      if (ep == arg)
+      {
+         fprintf(stderr, "makepng --color=...'%s': not a valid color\n", arg);
+         exit(1);
+      }
+
+      if (*ep) ++ep; /* skip a separator */
+      arg = ep;
+
+      colors[++ncolors] = (unsigned int)ul; /* checked above */
+   }
+
+   if (*arg)
+   {
+      fprintf(stderr, "makepng --color=...'%s': too many values\n", arg);
+      exit(1);
+   }
+
+   *colors = ncolors;
+}
+
 int
 main(int argc, char **argv)
 {
@@ -1101,14 +1280,17 @@ main(int argc, char **argv)
   const char *file_name = NULL;
   int color_type = 8; /* invalid */
   int bit_depth = 32; /* invalid */
+   unsigned int colors[5];
   unsigned int filters = PNG_ALL_FILTERS;
   png_fixed_point gamma = 0; /* not set */
   chunk_insert *head_insert = NULL;
   chunk_insert **insert_ptr = &head_insert;

+   memset(colors, 0, sizeof colors);
+
   while (--argc > 0)
   {
-      const char *arg = *++argv;
+      char *arg = *++argv;

      if (strcmp(arg, "--sRGB") == 0)
      {
@@ -1134,6 +1316,12 @@ main(int argc, char **argv)
         continue;
      }

+      if (strncmp(arg, "--color=", 8) == 0)
+      {
+          parse_color(arg+8, colors);
+          continue;
+      }
+
      if (argc >= 3 && strcmp(arg, "--insert") == 0)
      {
         png_const_charp what = *++argv;
@@ -1245,11 +1433,26 @@ main(int argc, char **argv)
   if (color_type == 8 || bit_depth == 32)
   {
      fprintf(stderr, "usage: makepng [--sRGB|--linear|--1.8] "
-         "color-type bit-depth [file-name]\n"
+         "[--color=...] color-type bit-depth [file-name]\n"
         "  Make a test PNG file, by default writes to stdout.\n");
      exit(1);
   }

+   /* Check the colors */
+   {
+      const unsigned int lim = (color_type == PNG_COLOR_TYPE_PALETTE ? 255U :
+         (1U<<bit_depth)-1);
+      unsigned int i;
+
+      for (i=1; i<=colors[0]; ++i)
+         if (colors[i] > lim)
+         {
+            fprintf(stderr, "makepng: --color=...: %u out of range [0..%u]\n",
+               colors[i], lim);
+            exit(1);
+         }
+   }
+
   /* Restrict the filters for more speed to those we know are used for the
    * generated images.
    */
@@ -1273,7 +1476,7 @@ main(int argc, char **argv)

   {
      int ret = write_png(&file_name, fp, color_type, bit_depth, gamma,
-         head_insert, filters);
+         head_insert, filters, colors);

      if (ret != 0 && file_name != NULL)
         remove(file_name);
--- a/contrib/libtests/pngstest.c
+++ b/contrib/libtests/pngstest.c
@@ -1,7 +1,7 @@
 /*-
 * pngstest.c
 *
- * Copyright (c) 2012 John Cunningham Bowler
+ * Copyright (c) 2013 John Cunningham Bowler
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
 *
@@ -2625,7 +2625,7 @@ component_loc(png_byte loc[4], png_uint_32 format)
   else
   {
      channels = 1;
-      loc[0] = loc[1] = loc[2] = 0;
+      loc[1] = loc[2] = loc[3] = 0;
   }

   if (format & PNG_FORMAT_FLAG_ALPHA)
--- a/contrib/libtests/pngunknown.c
+++ b/contrib/libtests/pngunknown.c
@@ -2,7 +2,7 @@
 /* pngunknown.c - test the read side unknown chunk handling
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 2012 Glenn Randers-Pehrson
+ * Copyright (c) 2013 Glenn Randers-Pehrson
 * Written by John Cunningham Bowler
 *
 * This code is released under the libpng license.
@@ -19,8 +19,16 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <setjmp.h>

-#include <png.h>
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif

 #ifdef PNG_READ_SUPPORTED

@@ -156,6 +164,14 @@ static struct

 #define NINFO ((int)((sizeof chunk_info)/(sizeof chunk_info[0])))

+static void
+clear_keep(void)
+{
+   int i = NINFO;
+   while (--i >= 0)
+      chunk_info[i].keep = 0;
+}
+
 static int
 find(const char *name)
 {
@@ -205,34 +221,101 @@ ancillaryb(const png_byte *name)
   return PNG_CHUNK_ANCILLARY(PNG_CHUNK(name[0], name[1], name[2], name[3]));
 }

-static int error_count = 0;
-static int warning_count = 0;
+/* Type of an error_ptr */
+typedef struct
+{
+   jmp_buf     error_return;
+   png_structp png_ptr;
+   png_infop   info_ptr, end_ptr;
+   int         error_count;
+   int         warning_count;
+   const char *program;
+   const char *file;
+   const char *test;
+} display;
+
+static const char init[] = "initialization";
+static const char cmd[] = "command line";

 static void
-error(png_structp png_ptr, const char *message)
+init_display(display *d, const char *program)
 {
-   fprintf(stderr, "libpng error: %s\n", message);
-   exit(1);
-   (void)png_ptr;
+   memset(d, 0, sizeof *d);
+   d->png_ptr = NULL;
+   d->info_ptr = d->end_ptr = NULL;
+   d->error_count = d->warning_count = 0;
+   d->program = program;
+   d->file = program;
+   d->test = init;
+}
+
+static void
+clean_display(display *d)
+{
+   png_destroy_read_struct(&d->png_ptr, &d->info_ptr, &d->end_ptr);
+
+   /* This must not happen - it might cause an app crash */
+   if (d->png_ptr != NULL || d->info_ptr != NULL || d->end_ptr != NULL)
+   {
+      fprintf(stderr, "%s(%s): png_destroy_read_struct error\n", d->file,
+         d->test);
+      exit(1);
+   }
+
+   /* Invalidate the test */
+   d->test = init;
+}
+
+PNG_FUNCTION(void, display_exit, (display *d), static PNG_NORETURN)
+{
+   ++(d->error_count);
+
+   if (d->png_ptr != NULL)
+      clean_display(d);
+
+   /* During initialization and if this is a single command line argument set
+    * exit now - there is only one test, otherwise longjmp to do the next test.
+    */
+   if (d->test == init || d->test == cmd)
+      exit(1);
+
+   longjmp(d->error_return, 1);
+}
+
+static int
+display_rc(const display *d, int strict)
+{
+   return d->error_count + (strict ? d->warning_count : 0);
+}
+
+/* libpng error and warning callbacks */
+PNG_FUNCTION(void, error, (png_structp png_ptr, const char *message),
+   static PNG_NORETURN)
+{
+   display *d = (display*)png_get_error_ptr(png_ptr);
+
+   fprintf(stderr, "%s(%s): libpng error: %s\n", d->file, d->test, message);
+   display_exit(d);
 }

 static void
 warning(png_structp png_ptr, const char *message)
 {
-   ++warning_count;
-   fprintf(stderr, "libpng warning: %s\n", message);
-   (void)png_ptr;
+   display *d = (display*)png_get_error_ptr(png_ptr);
+
+   fprintf(stderr, "%s(%s): libpng warning: %s\n", d->file, d->test, message);
+   ++(d->warning_count);
 }

 static png_uint_32
-get_valid(const char *file, png_const_structp png_ptr, png_const_infop info_ptr)
+get_valid(display *d, png_infop info_ptr)
 {
-   png_uint_32 flags = png_get_valid(png_ptr, info_ptr, (png_uint_32)~0);
+   png_uint_32 flags = png_get_valid(d->png_ptr, info_ptr, (png_uint_32)~0);

   /* Map the text chunks back into the flags */
   {
      png_textp text;
-      png_uint_32 ntext = png_get_text(png_ptr, info_ptr, &text, NULL);
+      png_uint_32 ntext = png_get_text(d->png_ptr, info_ptr, &text, NULL);

      while (ntext-- > 0) switch (text[ntext].compression)
      {
@@ -247,9 +330,9 @@ get_valid(const char *file, png_const_structp png_ptr, png_const_infop info_ptr)
            flags |= PNG_INFO_iTXt;
            break;
         default:
-            fprintf(stderr, "%s: unknown text compression %d\n", file,
-               text[ntext].compression);
-            exit(1);
+            fprintf(stderr, "%s(%s): unknown text compression %d\n", d->file,
+               d->test, text[ntext].compression);
+            display_exit(d);
      }
   }

@@ -257,14 +340,13 @@ get_valid(const char *file, png_const_structp png_ptr, png_const_infop info_ptr)
 }

 static png_uint_32
-get_unknown(const char *file, int def, png_const_structp png_ptr,
-   png_const_infop info_ptr)
+get_unknown(display *d, int def, png_infop info_ptr)
 {
   /* Create corresponding 'unknown' flags */
   png_uint_32 flags = 0;
   {
      png_unknown_chunkp unknown;
-      int num_unknown = png_get_unknown_chunks(png_ptr, info_ptr, &unknown);
+      int num_unknown = png_get_unknown_chunks(d->png_ptr, info_ptr, &unknown);

      while (--num_unknown >= 0)
      {
@@ -279,18 +361,19 @@ get_unknown(const char *file, int def, png_const_structp png_ptr,
            default: /* impossible */
            case PNG_HANDLE_CHUNK_AS_DEFAULT:
            case PNG_HANDLE_CHUNK_NEVER:
-               fprintf(stderr, "%s: %s: %s: unknown chunk saved\n",
-                  file, def ? "discard" : "default", unknown[num_unknown].name);
-               ++error_count;
+               fprintf(stderr, "%s(%s): %s: %s: unknown chunk saved\n",
+                  d->file, d->test, def ? "discard" : "default",
+                  unknown[num_unknown].name);
+               ++(d->error_count);
               break;

            case PNG_HANDLE_CHUNK_IF_SAFE:
               if (!ancillaryb(unknown[num_unknown].name))
               {
                  fprintf(stderr,
-                     "%s: if-safe: %s: unknown critical chunk saved\n",
-                     file, unknown[num_unknown].name);
-                  ++error_count;
+                     "%s(%s): if-safe: %s: unknown critical chunk saved\n",
+                     d->file, d->test, unknown[num_unknown].name);
+                  ++(d->error_count);
                  break;
               }
               /* FALL THROUGH (safe) */
@@ -307,35 +390,42 @@ get_unknown(const char *file, int def, png_const_structp png_ptr,
 }

 static int
-check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
+check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
+   display *d)
 {
-   png_structp png_ptr;
-   png_infop info_ptr, end_ptr;
   int i, def = PNG_HANDLE_CHUNK_AS_DEFAULT, npasses, ipass;
   png_uint_32 height;

-   png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, error, warning);
-   if (png_ptr == NULL)
+   /* Some of these errors are permanently fatal and cause an exit here, others
+    * are per-test and cause an error return.
+    */
+   d->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, d, error,
+      warning);
+   if (d->png_ptr == NULL)
   {
-      fprintf(stderr, "%s: could not allocate png struct\n", argv[argc]);
+      fprintf(stderr, "%s(%s): could not allocate png struct\n", d->file,
+         d->test);
+      /* Terminate here, this error is not test specific. */
      exit(1);
   }

-   info_ptr = png_create_info_struct(png_ptr);
-   end_ptr = png_create_info_struct(png_ptr);
-   if (info_ptr == NULL || end_ptr == NULL)
+   d->info_ptr = png_create_info_struct(d->png_ptr);
+   d->end_ptr = png_create_info_struct(d->png_ptr);
+   if (d->info_ptr == NULL || d->end_ptr == NULL)
   {
-      fprintf(stderr, "%s: could not allocate png info\n", argv[argc]);
+      fprintf(stderr, "%s(%s): could not allocate png info\n", d->file,
+         d->test);
+      clean_display(d);
      exit(1);
   }

-   png_init_io(png_ptr, fp);
+   png_init_io(d->png_ptr, fp);

   /* Handle each argument in turn; multiple settings are possible for the same
    * chunk and multiple calls will occur (the last one should override all
    * preceding ones).
    */
-   for (i=1; i<argc; ++i)
+   for (i=0; i<argc; ++i)
   {
      const char *equals = strchr(argv[i], '=');

@@ -353,8 +443,9 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
            option = PNG_HANDLE_CHUNK_ALWAYS;
         else
         {
-            fprintf(stderr, "%s: unrecognized chunk option\n", argv[i]);
-            exit(2);
+            fprintf(stderr, "%s(%s): %s: unrecognized chunk option\n", d->file,
+               d->test, argv[i]);
+            display_exit(d);
         }

         switch (equals - argv[i])
@@ -373,10 +464,8 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
                     png_byte name[5];

                     memcpy(name, chunk_info[chunk].name, 5);
-                     png_set_keep_unknown_chunks(png_ptr, option, name, 1);
+                     png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
                     chunk_info[chunk].keep = option;
-#                 else
-                     (void)option;
 #                 endif
                  continue;
               }
@@ -387,9 +476,9 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
               if (memcmp(argv[i], "default", 7) == 0)
               {
 #                 ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
-                     png_set_keep_unknown_chunks(png_ptr, option, NULL, 0);
-                     def = option;
+                     png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
 #                 endif
+                  def = option;
                  continue;
               }

@@ -399,7 +488,7 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
               if (memcmp(argv[i], "all", 3) == 0)
               {
 #                 ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
-                     png_set_keep_unknown_chunks(png_ptr, option, NULL, -1);
+                     png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
                     def = option;

                     for (chunk = 0; chunk < NINFO; ++chunk)
@@ -417,13 +506,14 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
         }
      }

-      fprintf(stderr, "%s: unrecognized chunk argument\n", argv[i]);
-      exit(2);
+      fprintf(stderr, "%s(%s): %s: unrecognized chunk argument\n", d->file,
+         d->test, argv[i]);
+      display_exit(d);
   }

-   png_read_info(png_ptr, info_ptr);
+   png_read_info(d->png_ptr, d->info_ptr);

-   switch (png_get_interlace_type(png_ptr, info_ptr))
+   switch (png_get_interlace_type(d->png_ptr, d->info_ptr))
   {
      case PNG_INTERLACE_NONE:
         npasses = 1;
@@ -434,7 +524,9 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
         break;

      default:
-         fprintf(stderr, "%s: invalid interlace type\n", argv[argc]);
+         /* Hard error because it is not test specific */
+         fprintf(stderr, "%s(%s): invalid interlace type\n", d->file, d->test);
+         clean_display(d);
         exit(1);
   }

@@ -443,12 +535,12 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
    */
   if (chunk_info[0/*IDAT*/].keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
   {
-      png_start_read_image(png_ptr);
-      height = png_get_image_height(png_ptr, info_ptr);
+      png_start_read_image(d->png_ptr);
+      height = png_get_image_height(d->png_ptr, d->info_ptr);

      if (npasses > 1)
      {
-         png_uint_32 width = png_get_image_width(png_ptr, info_ptr);
+         png_uint_32 width = png_get_image_width(d->png_ptr, d->info_ptr);

         for (ipass=0; ipass<npasses; ++ipass)
         {
@@ -459,7 +551,7 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
               png_uint_32 y;

               for (y=0; y<height; ++y) if (PNG_ROW_IN_INTERLACE_PASS(y, ipass))
-                  png_read_row(png_ptr, NULL, NULL);
+                  png_read_row(d->png_ptr, NULL, NULL);
            }
         }
      } /* interlaced */
@@ -469,49 +561,50 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/)
         png_uint_32 y;

         for (y=0; y<height; ++y)
-            png_read_row(png_ptr, NULL, NULL);
+            png_read_row(d->png_ptr, NULL, NULL);
      }
   }

-   png_read_end(png_ptr, end_ptr);
+   png_read_end(d->png_ptr, d->end_ptr);

-   flags[0] = get_valid(argv[argc], png_ptr, info_ptr);
-   flags[1] = get_unknown(argv[argc], def, png_ptr, info_ptr);
+   flags[0] = get_valid(d, d->info_ptr);
+   flags[1] = get_unknown(d, def, d->info_ptr);

   /* Only png_read_png sets PNG_INFO_IDAT! */
   flags[chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT] |=
      PNG_INFO_IDAT;

-   flags[2] = get_valid(argv[argc], png_ptr, end_ptr);
-   flags[3] = get_unknown(argv[argc], def, png_ptr, end_ptr);
+   flags[2] = get_valid(d, d->end_ptr);
+   flags[3] = get_unknown(d, def, d->end_ptr);

-   png_destroy_read_struct(&png_ptr, &info_ptr, &end_ptr);
+   clean_display(d);

   return def;
 }

 static void
-check_error(const char *file, png_uint_32 flags, const char *message)
+check_error(display *d, png_uint_32 flags, const char *message)
 {
   while (flags)
   {
-      png_uint_32 flag = flags & -flags;
+      png_uint_32 flag = flags & -(png_int_32)flags;
      int i = find_by_flag(flag);

-      fprintf(stderr, "%s: chunk %s: %s\n", file, chunk_info[i].name, message);
-      ++error_count;
+      fprintf(stderr, "%s(%s): chunk %s: %s\n", d->file, d->test,
+         chunk_info[i].name, message);
+      ++(d->error_count);

      flags &= ~flag;
   }
 }

 static void
-check_handling(const char *file, int def, png_uint_32 chunks, png_uint_32 known,
+check_handling(display *d, int def, png_uint_32 chunks, png_uint_32 known,
   png_uint_32 unknown, const char *position)
 {
   while (chunks)
   {
-      png_uint_32 flag = chunks & -chunks;
+      png_uint_32 flag = chunks & -(png_int_32)chunks;
      int i = find_by_flag(flag);
      int keep = chunk_info[i].keep;
      const char *type;
@@ -613,71 +706,36 @@ check_handling(const char *file, int def, png_uint_32 chunks, png_uint_32 known,

      if (errorx != NULL)
      {
-         ++error_count;
-         fprintf(stderr, "%s: %s %s %s: %s\n",
-            file, type, chunk_info[i].name, position, errorx);
+         ++(d->error_count);
+         fprintf(stderr, "%s(%s): %s %s %s: %s\n",
+            d->file, d->test, type, chunk_info[i].name, position, errorx);
      }

      chunks &= ~flag;
   }
 }

-int
-main(int argc, const char **argv)
+static void
+perform_one_test(FILE *fp, int argc, const char **argv,
+   png_uint_32 *default_flags, display *d)
 {
-   FILE *fp;
-   png_uint_32 flags[2/*default/+options*/][4/*valid,unknown{before,after}*/];
-   int def, strict = 0;
-   const char *program = argv[0];
-   const char *count_argv[3];
+   int def;
+   png_uint_32 flags[2][4];

-   if (argc > 1 && strcmp(argv[1], "--strict") == 0)
-   {
-      strict = 1;
-      --argc;
-      ++argv;
-   }
-
-   if (--argc < 1)
-   {
-      fprintf(stderr, "pngunknown: usage:\n"
-      " %s {(CHNK|default|all)=(default|discard|if-safe|save)} testfile.png\n",
-         program);
-      exit(2);
-   }
-
-#  ifndef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
-      fprintf(stderr,
-         "pngunknown: warning: no 'save' support so arguments ignored\n");
-#  endif
-   fp = fopen(argv[argc], "rb");
-   if (fp == NULL)
-   {
-      perror(argv[argc]);
-      exit(2);
-   }
-
-   /* First find all the chunks, known and unknown, in the test file: */
-   count_argv[0] = program;
-   count_argv[1] = "default=save";
-   count_argv[2] = argv[argc];
-   (void)check(fp, 2, count_argv, flags[0]);
-
-   /* Now find what the various supplied options cause to change: */
   rewind(fp);
-   def = check(fp, argc, argv, flags[1]);
-   fclose(fp);
+   clear_keep();
+   memcpy(flags[0], default_flags, sizeof flags[0]);
+
+   def = check(fp, argc, argv, flags[1], d);

   /* Chunks should either be known or unknown, never both and this should apply
    * whether the chunk is before or after the IDAT (actually, the app can
    * probably change this by swapping the handling after the image, but this
    * test does not do that.)
    */
-   check_error(argc[argv],
-      (flags[0][0]|flags[0][2]) & (flags[0][1]|flags[0][3]),
+   check_error(d, (flags[0][0]|flags[0][2]) & (flags[0][1]|flags[0][3]),
      "chunk handled inconsistently in count tests");
-   check_error(argc[argv],
-      (flags[1][0]|flags[1][2]) & (flags[1][1]|flags[1][3]),
+   check_error(d, (flags[1][0]|flags[1][2]) & (flags[1][1]|flags[1][3]),
      "chunk handled inconsistently in option tests");

   /* Now find out what happened to each chunk before and after the IDAT and
@@ -689,25 +747,206 @@ main(int argc, const char **argv)
      png_uint_32 test;

      test = flags[1][0] & ~flags[0][0];
-      check_error(argv[argc], test, "new known chunk before IDAT");
+      check_error(d, test, "new known chunk before IDAT");
      test = flags[1][1] & ~(flags[0][0] | flags[0][1]);
-      check_error(argv[argc], test, "new unknown chunk before IDAT");
+      check_error(d, test, "new unknown chunk before IDAT");
      test = flags[1][2] & ~flags[0][2];
-      check_error(argv[argc], test, "new known chunk after IDAT");
+      check_error(d, test, "new known chunk after IDAT");
      test = flags[1][3] & ~(flags[0][2] | flags[0][3]);
-      check_error(argv[argc], test, "new unknown chunk after IDAT");
+      check_error(d, test, "new unknown chunk after IDAT");
   }

   /* Now each chunk in the original list should have been handled according to
    * the options set for that chunk, regardless of whether libpng knows about
    * it or not.
    */
-   check_handling(argv[argc], def, flags[0][0] | flags[0][1], flags[1][0],
-      flags[1][1], "before IDAT");
-   check_handling(argv[argc], def, flags[0][2] | flags[0][3], flags[1][2],
-      flags[1][3], "after IDAT");
+   check_handling(d, def, flags[0][0] | flags[0][1], flags[1][0], flags[1][1],
+      "before IDAT");
+   check_handling(d, def, flags[0][2] | flags[0][3], flags[1][2], flags[1][3],
+      "after IDAT");
+}

-   return error_count + (strict ? warning_count : 0);
+static void
+perform_one_test_safe(FILE *fp, int argc, const char **argv,
+   png_uint_32 *default_flags, display *d, const char *test)
+{
+   if (setjmp(d->error_return) == 0)
+   {
+      d->test = test; /* allow use of d->error_return */
+      perform_one_test(fp, argc, argv, default_flags, d);
+      d->test = init; /* prevent use of d->error_return */
+   }
+}
+
+static const char *standard_tests[] =
+{
+ "discard", "default=discard", 0,
+ "save", "default=save", 0,
+ "if-safe", "default=if-safe", 0,
+ "vpAg", "vpAg=if-safe", 0,
+ "sTER", "sTER=if-safe", 0,
+ "IDAT", "default=discard", "IDAT=save", 0,
+ "sAPI", "bKGD=save", "cHRM=save", "gAMA=save", "all=discard", "iCCP=save",
+   "sBIT=save", "sRGB=save", 0,
+ 0/*end*/
+};
+
+static PNG_NORETURN void
+usage(const char *program, const char *reason)
+{
+   fprintf(stderr, "pngunknown: %s: usage:\n %s [--strict] "
+      "--default|{(CHNK|default|all)=(default|discard|if-safe|save)} "
+      "testfile.png\n", reason, program);
+   exit(2);
+}
+
+int
+main(int argc, const char **argv)
+{
+   FILE *fp;
+   png_uint_32 default_flags[4/*valid,unknown{before,after}*/];
+   int strict = 0, default_tests = 0;
+   const char *count_argv = "default=save";
+   const char *touch_file = NULL;
+   display d;
+
+   init_display(&d, argv[0]);
+
+   while (++argv, --argc > 0)
+   {
+      if (strcmp(*argv, "--strict") == 0)
+         strict = 1;
+
+      else if (strcmp(*argv, "--default") == 0)
+         default_tests = 1;
+
+      else if (strcmp(*argv, "--touch") == 0)
+      {
+         if (argc > 1)
+            touch_file = *++argv, --argc;
+
+         else
+            usage(d.program, "--touch: missing file name");
+      }
+
+      else
+         break;
+   }
+
+   /* A file name is required, but there should be no other arguments if
+    * --default was specified.
+    */
+   if (argc <= 0)
+      usage(d.program, "missing test file");
+
+   /* GCC BUG: if (default_tests && argc != 1) triggers some weird GCC argc
+    * optimization which causes warnings with -Wstrict-overflow!
+    */
+   else if (default_tests) if (argc != 1)
+      usage(d.program, "extra arguments");
+
+#  ifndef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+      fprintf(stderr, "%s: warning: no 'save' support so arguments ignored\n",
+         d.program);
+#  endif
+
+   /* The name of the test file is the last argument; remove it. */
+   d.file = argv[--argc];
+
+   fp = fopen(d.file, "rb");
+   if (fp == NULL)
+   {
+      perror(d.file);
+      exit(2);
+   }
+
+   /* First find all the chunks, known and unknown, in the test file, a failure
+    * here aborts the whole test.
+    */
+   if (check(fp, 1, &count_argv, default_flags, &d) !=
+      PNG_HANDLE_CHUNK_ALWAYS)
+   {
+      fprintf(stderr, "%s: %s: internal error\n", d.program, d.file);
+      exit(3);
+   }
+
+   /* Now find what the various supplied options cause to change: */
+   if (!default_tests)
+   {
+      d.test = cmd; /* acts as a flag to say exit, do not longjmp */
+      perform_one_test(fp, argc, argv, default_flags, &d);
+      d.test = init;
+   }
+
+   else
+   {
+      const char **test = standard_tests;
+
+      /* Set the exit_test pointer here so we can continue after a libpng error.
+       * NOTE: this leaks memory because the png_struct data from the failing
+       * test is never freed.
+       */
+      while (*test)
+      {
+         const char *this_test = *test++;
+         const char **next = test;
+         int count = display_rc(&d, strict), new_count;
+         const char *result;
+         int arg_count = 0;
+
+         while (*next) ++next, ++arg_count;
+
+         perform_one_test_safe(fp, arg_count, test, default_flags, &d,
+            this_test);
+
+         new_count = display_rc(&d, strict);
+
+         if (new_count == count)
+            result = "PASS";
+
+         else
+            result = "FAIL";
+
+         printf("%s: %s %s\n", result, d.program, this_test);
+
+         test = next+1;
+      }
+   }
+
+   fclose(fp);
+
+   if (display_rc(&d, strict) == 0)
+   {
+      /* Success, touch the success file if appropriate */
+      if (touch_file != NULL)
+      {
+         FILE *fsuccess = fopen(touch_file, "wt");
+
+         if (fsuccess != NULL)
+         {
+            int err = 0;
+            fprintf(fsuccess, "PNG unknown tests succeeded\n");
+            fflush(fsuccess);
+            err = ferror(fsuccess);
+
+            if (fclose(fsuccess) || err)
+            {
+               fprintf(stderr, "%s: write failed\n", touch_file);
+               exit(1);
+            }
+         }
+
+         else
+         {
+            fprintf(stderr, "%s: open failed\n", touch_file);
+            exit(1);
+         }
+      }
+
+      return 0;
+   }
+
+   return 1;
 }

 #else
--- a/contrib/libtests/pngvalid.c
+++ b/contrib/libtests/pngvalid.c
@@ -2,7 +2,7 @@
 /* pngvalid.c - validate libpng by constructing then reading png files.
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 2012 Glenn Randers-Pehrson
+ * Copyright (c) 2013 Glenn Randers-Pehrson
 * Written by John Cunningham Bowler
 *
 * This code is released under the libpng license.
@@ -107,7 +107,11 @@ typedef png_byte *png_const_bytep;
 #endif

 /***************************** EXCEPTION HANDLING *****************************/
-#include "../visupng/cexcept.h"
+#ifdef PNG_FREESTANDING_TESTS
+#  include <cexcept.h>
+#else
+#  include "../visupng/cexcept.h"
+#endif

 #ifdef __cplusplus
 #  define this not_the_cpp_this
@@ -187,7 +191,8 @@ fix(double d)
 * is implemented here so that it gives the same set of numbers on every
 * architecture.  It's a linear congruential generator (Knuth or Sedgewick
 * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
- * Hill, "The Art of Electronics".
+ * Hill, "The Art of Electronics" (Pseudo-Random Bit Sequences and Noise
+ * Generation.)
 */
 static void
 make_random_bytes(png_uint_32* seed, void* pv, size_t size)
@@ -240,6 +245,7 @@ random_mod(unsigned int max)
   return x % max; /* 0 .. max-1 */
 }

+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 static int
 random_choice(void)
 {
@@ -249,6 +255,7 @@ random_choice(void)

   return x & 1;
 }
+#endif
 #endif /* PNG_READ_SUPPORTED */

 /* A numeric ID based on PNG file characteristics.  The 'do_interlace' field
@@ -1710,6 +1717,7 @@ white_point(PNG_CONST color_encoding *encoding)
   return white;
 }

+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 static void
 normalize_color_encoding(color_encoding *encoding)
 {
@@ -1729,6 +1737,7 @@ normalize_color_encoding(color_encoding *encoding)
      encoding->blue.Z /= whiteY;
   }
 }
+#endif

 static size_t
 safecat_color_encoding(char *buffer, size_t bufsize, size_t pos,
@@ -1963,6 +1972,7 @@ modifier_init(png_modifier *pm)
 * to a calculation - not a digitization operation - unless the following API is
 * called directly.
 */
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 static double digitize(PNG_CONST png_modifier *pm, double value,
   int sample_depth, int do_round)
 {
@@ -1987,7 +1997,10 @@ static double digitize(PNG_CONST png_modifier *pm, double value,
   if (do_round) value += .5;
   return floor(value)/digitization_factor;
 }
+#endif

+#if (defined PNG_READ_GAMMA_SUPPORTED) ||\
+   (defined PNG_READ_RGB_TO_GRAY_SUPPORTED)
 static double abserr(PNG_CONST png_modifier *pm, int in_depth, int out_depth)
 {
   /* Absolute error permitted in linear values - affected by the bit depth of
@@ -1999,7 +2012,9 @@ static double abserr(PNG_CONST png_modifier *pm, int in_depth, int out_depth)
   else
      return pm->maxabs8;
 }
+#endif

+#ifdef PNG_READ_GAMMA_SUPPORTED
 static double calcerr(PNG_CONST png_modifier *pm, int in_depth, int out_depth)
 {
   /* Error in the linear composition arithmetic - only relevant when
@@ -2116,6 +2131,7 @@ static int output_quantization_factor(PNG_CONST png_modifier *pm, int in_depth,
   else
      return 1;
 }
+#endif /* PNG_READ_GAMMA_SUPPORTED */

 /* One modification structure must be provided for each chunk to be modified (in
 * fact more than one can be provided if multiple separate changes are desired
@@ -2168,6 +2184,7 @@ modification_init(png_modification *pmm)
   modification_reset(pmm);
 }

+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 static void
 modifier_current_encoding(PNG_CONST png_modifier *pm, color_encoding *ce)
 {
@@ -2179,6 +2196,7 @@ modifier_current_encoding(PNG_CONST png_modifier *pm, color_encoding *ce)

   ce->gamma = pm->current_gamma;
 }
+#endif

 static size_t
 safecat_current_encoding(char *buffer, size_t bufsize, size_t pos,
@@ -2804,6 +2822,7 @@ srgb_modification_init(srgb_modification *me, png_modifier *pm, png_byte intent)
   pm->modifications = &me->this;
 }

+#ifdef PNG_READ_GAMMA_SUPPORTED
 typedef struct sbit_modification
 {
   png_modification this;
@@ -2870,6 +2889,7 @@ sbit_modification_init(sbit_modification *me, png_modifier *pm, png_byte sbit)
   me->this.next = pm->modifications;
   pm->modifications = &me->this;
 }
+#endif /* PNG_READ_GAMMA_SUPPORTED */
 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */

 /***************************** STANDARD PNG FILES *****************************/
@@ -4734,7 +4754,7 @@ standard_check_text(png_const_structp pp, png_const_textp tp,

 static void
 standard_text_validate(standard_display *dp, png_const_structp pp,
-   png_const_infop pi)
+   png_infop pi)
 {
   png_textp tp = NULL;
   png_uint_32 num_text = png_get_text(pp, pi, &tp, NULL);
@@ -5996,6 +6016,7 @@ image_transform_default_ini(PNG_CONST image_transform *this,
   this->next->ini(this->next, that);
 }

+#ifdef PNG_READ_BACKGROUND_SUPPORTED
 static int
 image_transform_default_add(image_transform *this,
    PNG_CONST image_transform **that, png_byte colour_type, png_byte bit_depth)
@@ -6008,6 +6029,7 @@ image_transform_default_add(image_transform *this,

   return 1;
 }
+#endif

 #ifdef PNG_READ_EXPAND_SUPPORTED
 /* png_set_palette_to_rgb */
@@ -7686,6 +7708,7 @@ gamma_component_compose(int do_background, double input_sample, double alpha,
 {
   switch (do_background)
   {
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
      case PNG_BACKGROUND_GAMMA_SCREEN:
      case PNG_BACKGROUND_GAMMA_FILE:
      case PNG_BACKGROUND_GAMMA_UNIQUE:
@@ -7703,6 +7726,7 @@ gamma_component_compose(int do_background, double input_sample, double alpha,
               input_sample = background;
         }
         break;
+#endif

 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
      case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
@@ -7735,6 +7759,9 @@ gamma_component_compose(int do_background, double input_sample, double alpha,
         /* Standard cases where no compositing is done (so the component
          * value is already correct.)
          */
+         UNUSED(alpha)
+         UNUSED(background)
+         UNUSED(compose)
         break;
   }

@@ -8134,11 +8161,13 @@ gamma_component_validate(PNG_CONST char *name, PNG_CONST validate_info *vi,
             */
            switch (do_background)
            {
-            case PNG_BACKGROUND_GAMMA_SCREEN:
-            case PNG_BACKGROUND_GAMMA_FILE:
-            case PNG_BACKGROUND_GAMMA_UNIQUE:
-               use_background = (alpha >= 0 && alpha < 1);
-               /*FALL THROUGH*/
+#           ifdef PNG_READ_BACKGROUND_SUPPORTED
+               case PNG_BACKGROUND_GAMMA_SCREEN:
+               case PNG_BACKGROUND_GAMMA_FILE:
+               case PNG_BACKGROUND_GAMMA_UNIQUE:
+                  use_background = (alpha >= 0 && alpha < 1);
+                  /*FALL THROUGH*/
+#           endif
 #           ifdef PNG_READ_ALPHA_MODE_SUPPORTED
               case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
               case ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN:
@@ -9057,7 +9086,9 @@ perform_gamma_test(png_modifier *pm, int summary)
   /* Save certain values for the temporary overrides below. */
   unsigned int calculations_use_input_precision =
      pm->calculations_use_input_precision;
-   double maxout8 = pm->maxout8;
+#  ifdef PNG_READ_BACKGROUND_SUPPORTED
+      double maxout8 = pm->maxout8;
+#  endif

   /* First some arbitrary no-transform tests: */
   if (!pm->this.speed && pm->test_gamma_threshold)
@@ -10090,6 +10121,12 @@ int main(int argc, char **argv)
            exit(1);
         }
      }
+
+      else
+      {
+         fprintf(stderr, "%s: open failed\n", touch);
+         exit(1);
+      }
   }

   return 0;
--- a/contrib/libtests/readpng.c
+++ b/contrib/libtests/readpng.c
@@ -0,0 +1,104 @@
+/* readpng.c
+ *
+ * Copyright (c) 2013 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Load an arbitrary number of PNG files (from the command line, or, if there
+ * are no arguments on the command line, from stdin) then run a time test by
+ * reading each file by row.  The test does nothing with the read result and
+ * does no transforms.  The only output is a time as a floating point number of
+ * seconds with 9 decimal digits.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#if (defined HAVE_CONFIG_H) && !(defined PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+static int
+read_png(FILE *fp)
+{
+   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
+   png_infop info_ptr = NULL;
+   png_bytep row = NULL, display = NULL;
+
+   if (png_ptr == NULL)
+      return 0;
+
+   if (setjmp(png_jmpbuf(png_ptr)))
+   {
+      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+      if (row != NULL) free(row);
+      if (display != NULL) free(display);
+      return 0;
+   }
+
+   png_init_io(png_ptr, fp);
+
+   info_ptr = png_create_info_struct(png_ptr);
+   if (info_ptr == NULL)
+      png_error(png_ptr, "OOM allocating info structure");
+
+   png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_ALWAYS, NULL, 0);
+
+   png_read_info(png_ptr, info_ptr);
+
+   {
+      png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+
+      row = malloc(rowbytes);
+      display = malloc(rowbytes);
+
+      if (row == NULL || display == NULL)
+         png_error(png_ptr, "OOM allocating row buffers");
+
+      {
+         png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
+         int passes = png_set_interlace_handling(png_ptr);
+         int pass;
+
+         png_start_read_image(png_ptr);
+
+         for (pass = 0; pass < passes; ++pass)
+         {
+            png_uint_32 y = height;
+
+            /* NOTE: this trashes the row each time; interlace handling won't
+             * work, but this avoids memory thrashing for speed testing.
+             */
+            while (y-- > 0)
+               png_read_row(png_ptr, row, display);
+         }
+      }
+   }
+
+   /* Make sure to read to the end of the file: */
+   png_read_end(png_ptr, info_ptr);
+   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+   free(row);
+   free(display);
+   return 1;
+}
+
+int
+main(void)
+{
+   /* Exit code 0 on success. */
+   return !read_png(stdin);
+}
--- a/contrib/libtests/tarith.c
+++ b/contrib/libtests/tarith.c
@@ -1,7 +1,7 @@

 /* tarith.c
 *
- * Copyright (c) 2011,2012 John Cunningham Bowler
+ * Copyright (c) 2011-2013 John Cunningham Bowler
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
 *
@@ -92,12 +92,12 @@ int validation_ascii_to_fp(int count, int argc, char **argv)
         showall = 1;
      else if (strcmp(*argv, "-e") == 0 && argc > 0)
      {
-	 --argc;
+         --argc;
         max_error = atof(*++argv);
      }
      else if (strcmp(*argv, "-E") == 0 && argc > 0)
      {
-	 --argc;
+         --argc;
         max_error_abs = atof(*++argv);
      }
      else
@@ -118,7 +118,7 @@ int validation_ascii_to_fp(int count, int argc, char **argv)
         ++nonfinite;

      if (verbose)
-	 fprintf(stderr, "%.*g %d\n", DBL_DIG, test, precision);
+         fprintf(stderr, "%.*g %d\n", DBL_DIG, test, precision);

      /* Check for overflow in the buffer by setting a marker. */
      memset(buffer, 71, sizeof buffer);
@@ -131,8 +131,8 @@ int validation_ascii_to_fp(int count, int argc, char **argv)
      if (buffer[precision+7] != 71)
      {
         fprintf(stderr, "%g[%d] -> '%s'[%lu] buffer overflow\n", test,
-	    precision, buffer, (unsigned long)strlen(buffer));
-	 failed = 1;
+            precision, buffer, (unsigned long)strlen(buffer));
+         failed = 1;
      }

      /* Following are used for the number parser below and must be
@@ -143,19 +143,19 @@ int validation_ascii_to_fp(int count, int argc, char **argv)
      if (!isfinite(test))
      {
         /* Expect 'inf' */
-	 if (test >= 0 && strcmp(buffer, "inf") ||
-	     test <  0 && strcmp(buffer, "-inf"))
-	 {
-	    fprintf(stderr, "%g[%d] -> '%s' but expected 'inf'\n", test,
-	       precision, buffer);
-	    failed = 1;
-	 }
+         if (test >= 0 && strcmp(buffer, "inf") ||
+             test <  0 && strcmp(buffer, "-inf"))
+         {
+            fprintf(stderr, "%g[%d] -> '%s' but expected 'inf'\n", test,
+               precision, buffer);
+            failed = 1;
+         }
      }
      else if (!png_check_fp_number(buffer, precision+10, &state, &index) ||
          buffer[index] != 0)
      {
-	 fprintf(stderr, "%g[%d] -> '%s' but has bad format ('%c')\n", test,
-	 precision, buffer, buffer[index]);
+         fprintf(stderr, "%g[%d] -> '%s' but has bad format ('%c')\n", test,
+         precision, buffer, buffer[index]);
         failed = 1;
      }
      else if (PNG_FP_IS_NEGATIVE(state) && !(test < 0))
@@ -185,21 +185,21 @@ int validation_ascii_to_fp(int count, int argc, char **argv)
      else
      {
         /* Check the result against the original. */
-	 double out = atof(buffer);
-	 double change = fabs((out - test)/test);
-	 double allow = .5/pow(10,
+         double out = atof(buffer);
+         double change = fabs((out - test)/test);
+         double allow = .5/pow(10,
            (precision >= DBL_DIG) ? DBL_DIG-1 : precision-1);

-	 /* NOTE: if you hit this error case are you compiling with gcc
-	  * and -O0?  Try -O2 - the errors can accumulate if the FP
-	  * code above is not optimized and may drift outside the .5 in
-	  * DBL_DIG allowed.  In any case a small number of errors may
-	  * occur (very small ones - 1 or 2%) because of rounding in the
-	  * calculations, either in the conversion API or in atof.
-	  */
-	 if (change >= allow && (isfinite(out) ||
-	     fabs(test/DBL_MAX) <= 1-allow))
-	 {
+         /* NOTE: if you hit this error case are you compiling with gcc
+          * and -O0?  Try -O2 - the errors can accumulate if the FP
+          * code above is not optimized and may drift outside the .5 in
+          * DBL_DIG allowed.  In any case a small number of errors may
+          * occur (very small ones - 1 or 2%) because of rounding in the
+          * calculations, either in the conversion API or in atof.
+          */
+         if (change >= allow && (isfinite(out) ||
+             fabs(test/DBL_MAX) <= 1-allow))
+         {
            double percent = (precision >= DBL_DIG) ? max_error_abs : max_error;
            double allowp = (change-allow)*100/allow;

@@ -213,16 +213,16 @@ int validation_ascii_to_fp(int count, int argc, char **argv)
               if (max < allowp) max = allowp;
            }

-	    if (showall || allowp >= percent)
-	    {
-	       fprintf(stderr,
-		  "%.*g[%d] -> '%s' -> %.*g number changed (%g > %g (%d%%))\n",
-		  DBL_DIG, test, precision, buffer, DBL_DIG, out, change, allow,
-		  (int)round(allowp));
-	       failed = 1;
-	    }
-	    else
-	       ++minorarith;
+            if (showall || allowp >= percent)
+            {
+               fprintf(stderr,
+                  "%.*g[%d] -> '%s' -> %.*g number changed (%g > %g (%d%%))\n",
+                  DBL_DIG, test, precision, buffer, DBL_DIG, out, change, allow,
+                  (int)round(allowp));
+               failed = 1;
+            }
+            else
+               ++minorarith;
         }
      }

@@ -239,15 +239,15 @@ skip:

      /* Generate random numbers. */
      if (test == 0 || !isfinite(test))
-	 test = precision+1;
+         test = precision+1;
      else
      {
-	 /* Derive the exponent from the previous rand() value. */
-	 int exponent = precision % (DBL_MAX_EXP - DBL_MIN_EXP) + DBL_MIN_EXP;
-	 int tmp;
-	 test = frexp(test * rand(), &tmp);
-	 test = ldexp(test, exponent);
-	 precision >>= 8; /* arbitrary */
+         /* Derive the exponent from the previous rand() value. */
+         int exponent = precision % (DBL_MAX_EXP - DBL_MIN_EXP) + DBL_MIN_EXP;
+         int tmp;
+         test = frexp(test * rand(), &tmp);
+         test = ldexp(test, exponent);
+         precision >>= 8; /* arbitrary */
      }

      /* This limits the precision to 32 digits, enough for standard
@@ -646,17 +646,17 @@ int validation_muldiv(int count, int argc, char **argv)
       */
      {
         long u1, u2;
-	 int n = 0;
-	 if (a < 0) u1 = -a, n = 1; else u1 = a;
-	 if (times < 0) u2 = -times, n = !n; else u2 = times;
-	 png_64bit_product(u1, u2, &hi, &lo);
-	 if (n)
-	 {
-	    /* -x = ~x+1 */
-	    lo = ((~lo) + 1) & 0xffffffff;
-	    hi = ~hi;
-	    if (lo == 0) ++hi;
-	 }
+         int n = 0;
+         if (a < 0) u1 = -a, n = 1; else u1 = a;
+         if (times < 0) u2 = -times, n = !n; else u2 = times;
+         png_64bit_product(u1, u2, &hi, &lo);
+         if (n)
+         {
+            /* -x = ~x+1 */
+            lo = ((~lo) + 1) & 0xffffffff;
+            hi = ~hi;
+            if (lo == 0) ++hi;
+         }
      }

      fp = a;
@@ -664,48 +664,48 @@ int validation_muldiv(int count, int argc, char **argv)
      if ((fp & 0xffffffff) != lo || ((fp >> 32) & 0xffffffff) != hi)
      {
         fprintf(stderr, "png_64bit_product %d * %d -> %lx|%.8lx not %llx\n",
-	    a, times, hi, lo, fp);
-	 ++error64;
+            a, times, hi, lo, fp);
+         ++error64;
      }

      if (div != 0)
      {
-	 /* Round - this is C round to zero. */
-	 if ((fp < 0) != (div < 0))
-	   fp -= div/2;
-	 else
-	   fp += div/2;
+         /* Round - this is C round to zero. */
+         if ((fp < 0) != (div < 0))
+           fp -= div/2;
+         else
+           fp += div/2;

-	 fp /= div;
-	 fpround = fp;
-	 /* Assume 2's complement here: */
-	 ok = fpround <= PNG_UINT_31_MAX &&
-	      fpround >= -1-(long long int)PNG_UINT_31_MAX;
-	 if (!ok) ++overflow;
+         fp /= div;
+         fpround = fp;
+         /* Assume 2's complement here: */
+         ok = fpround <= PNG_UINT_31_MAX &&
+              fpround >= -1-(long long int)PNG_UINT_31_MAX;
+         if (!ok) ++overflow;
      }
      else
        ok = 0, ++overflow, fpround = fp/*misleading*/;

      if (verbose)
         fprintf(stderr, "TEST %d * %d / %d -> %lld (%s)\n", a, times, div,
-	    fp, ok ? "ok" : "overflow");
+            fp, ok ? "ok" : "overflow");

      ++tested;
      if (png_muldiv(&result, a, times, div) != ok)
      {
-	 ++error;
-	 if (ok)
-	     fprintf(stderr, "%d * %d / %d -> overflow (expected %lld)\n", a,
-	        times, div, fp);
+         ++error;
+         if (ok)
+             fprintf(stderr, "%d * %d / %d -> overflow (expected %lld)\n", a,
+                times, div, fp);
         else
-	     fprintf(stderr, "%d * %d / %d -> %d (expected overflow %lld)\n", a,
-	        times, div, result, fp);
+             fprintf(stderr, "%d * %d / %d -> %d (expected overflow %lld)\n", a,
+                times, div, result, fp);
      }
      else if (ok && result != fpround)
      {
         ++error;
         fprintf(stderr, "%d * %d / %d -> %d not %lld\n", a, times, div, result,
-	    fp);
+            fp);
      }
      else
         ++passed;
@@ -775,7 +775,7 @@ int validation_gamma(int argc, char **argv)
   /* Silence the output with -s, just test the gamma functions with -g: */
   while (--argc > 0)
      if (strcmp(*++argv, "-s") == 0)
-	 silent = 1;
+         silent = 1;
      else if (strcmp(*argv, "-g") == 0)
         onlygamma = 1;
      else
@@ -790,100 +790,100 @@ int validation_gamma(int argc, char **argv)
      maxerr = 0;
      for (i=0; i<256; ++i)
      {
-	 double correct = -log(i/255.)/log(2.)*65536;
-	 double error = png_log8bit(i) - correct;
+         double correct = -log(i/255.)/log(2.)*65536;
+         double error = png_log8bit(i) - correct;

-	 if (i != 0 && fabs(error) > maxerr)
-	    maxerr = fabs(error);
+         if (i != 0 && fabs(error) > maxerr)
+            maxerr = fabs(error);

-	 if (i == 0 && png_log8bit(i) != 0xffffffff ||
-	     i != 0 && png_log8bit(i) != floor(correct+.5))
-	 {
-	    fprintf(stderr, "8 bit log error: %d: got %u, expected %f\n",
-	       i, png_log8bit(i), correct);
-	 }
+         if (i == 0 && png_log8bit(i) != 0xffffffff ||
+             i != 0 && png_log8bit(i) != floor(correct+.5))
+         {
+            fprintf(stderr, "8 bit log error: %d: got %u, expected %f\n",
+               i, png_log8bit(i), correct);
+         }
      }

      if (!silent)
-	 printf("maximum 8 bit log error = %f\n", maxerr);
+         printf("maximum 8 bit log error = %f\n", maxerr);

      maxerr = 0;
      for (i=0; i<65536; ++i)
      {
-	 double correct = -log(i/65535.)/log(2.)*65536;
-	 double error = png_log16bit(i) - correct;
+         double correct = -log(i/65535.)/log(2.)*65536;
+         double error = png_log16bit(i) - correct;

-	 if (i != 0 && fabs(error) > maxerr)
-	    maxerr = fabs(error);
+         if (i != 0 && fabs(error) > maxerr)
+            maxerr = fabs(error);

-	 if (i == 0 && png_log16bit(i) != 0xffffffff ||
-	     i != 0 && png_log16bit(i) != floor(correct+.5))
-	 {
-	    if (error > .68) /* By experiment error is less than .68 */
-	    {
-	       fprintf(stderr, "16 bit log error: %d: got %u, expected %f"
-		  " error: %f\n", i, png_log16bit(i), correct, error);
-	    }
-	 }
+         if (i == 0 && png_log16bit(i) != 0xffffffff ||
+             i != 0 && png_log16bit(i) != floor(correct+.5))
+         {
+            if (error > .68) /* By experiment error is less than .68 */
+            {
+               fprintf(stderr, "16 bit log error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_log16bit(i), correct, error);
+            }
+         }
      }

      if (!silent)
-	 printf("maximum 16 bit log error = %f\n", maxerr);
+         printf("maximum 16 bit log error = %f\n", maxerr);

      /* Now exponentiations. */
      maxerr = 0;
      for (i=0; i<=0xfffff; ++i)
      {
-	 double correct = exp(-i/65536. * log(2.)) * (65536. * 65536);
-	 double error = png_exp(i) - correct;
+         double correct = exp(-i/65536. * log(2.)) * (65536. * 65536);
+         double error = png_exp(i) - correct;

-	 if (fabs(error) > maxerr)
-	    maxerr = fabs(error);
-	 if (fabs(error) > 1883) /* By experiment. */
-	 {
-	    fprintf(stderr, "32 bit exp error: %d: got %u, expected %f"
-		  " error: %f\n", i, png_exp(i), correct, error);
-	 }
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > 1883) /* By experiment. */
+         {
+            fprintf(stderr, "32 bit exp error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_exp(i), correct, error);
+         }
      }

      if (!silent)
-	 printf("maximum 32 bit exp error = %f\n", maxerr);
+         printf("maximum 32 bit exp error = %f\n", maxerr);

      maxerr = 0;
      for (i=0; i<=0xfffff; ++i)
      {
-	 double correct = exp(-i/65536. * log(2.)) * 255;
-	 double error = png_exp8bit(i) - correct;
+         double correct = exp(-i/65536. * log(2.)) * 255;
+         double error = png_exp8bit(i) - correct;

-	 if (fabs(error) > maxerr)
-	    maxerr = fabs(error);
-	 if (fabs(error) > .50002) /* By experiment */
-	 {
-	    fprintf(stderr, "8 bit exp error: %d: got %u, expected %f"
-		  " error: %f\n", i, png_exp8bit(i), correct, error);
-	 }
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > .50002) /* By experiment */
+         {
+            fprintf(stderr, "8 bit exp error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_exp8bit(i), correct, error);
+         }
      }

      if (!silent)
-	 printf("maximum 8 bit exp error = %f\n", maxerr);
+         printf("maximum 8 bit exp error = %f\n", maxerr);

      maxerr = 0;
      for (i=0; i<=0xfffff; ++i)
      {
-	 double correct = exp(-i/65536. * log(2.)) * 65535;
-	 double error = png_exp16bit(i) - correct;
+         double correct = exp(-i/65536. * log(2.)) * 65535;
+         double error = png_exp16bit(i) - correct;

-	 if (fabs(error) > maxerr)
-	    maxerr = fabs(error);
-	 if (fabs(error) > .524) /* By experiment */
-	 {
-	    fprintf(stderr, "16 bit exp error: %d: got %u, expected %f"
-		  " error: %f\n", i, png_exp16bit(i), correct, error);
-	 }
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > .524) /* By experiment */
+         {
+            fprintf(stderr, "16 bit exp error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_exp16bit(i), correct, error);
+         }
      }

      if (!silent)
-	 printf("maximum 16 bit exp error = %f\n", maxerr);
+         printf("maximum 16 bit exp error = %f\n", maxerr);
   } /* !onlygamma */

   /* Test the overall gamma correction. */
@@ -894,45 +894,45 @@ int validation_gamma(int argc, char **argv)
      png_fixed_point gfp = floor(g * PNG_FP_1 + .5);

      if (!silent)
-	 printf("Test gamma %f\n", g);
+         printf("Test gamma %f\n", g);

      maxerr = 0;
      for (j=0; j<256; ++j)
      {
         double correct = pow(j/255., g) * 255;
-	 png_byte out = png_gamma_8bit_correct(j, gfp);
-	 double error = out - correct;
+         png_byte out = png_gamma_8bit_correct(j, gfp);
+         double error = out - correct;

-	 if (fabs(error) > maxerr)
-	    maxerr = fabs(error);
-	 if (out != floor(correct+.5))
-	 {
-	    fprintf(stderr, "8bit %d ^ %f: got %d expected %f error %f\n",
-	       j, g, out, correct, error);
-	 }
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (out != floor(correct+.5))
+         {
+            fprintf(stderr, "8bit %d ^ %f: got %d expected %f error %f\n",
+               j, g, out, correct, error);
+         }
      }

      if (!silent)
-	 printf("gamma %f: maximum 8 bit error %f\n", g, maxerr);
+         printf("gamma %f: maximum 8 bit error %f\n", g, maxerr);

      maxerr = 0;
      for (j=0; j<65536; ++j)
      {
         double correct = pow(j/65535., g) * 65535;
-	 png_uint_16 out = png_gamma_16bit_correct(j, gfp);
-	 double error = out - correct;
+         png_uint_16 out = png_gamma_16bit_correct(j, gfp);
+         double error = out - correct;

-	 if (fabs(error) > maxerr)
-	    maxerr = fabs(error);
-	 if (fabs(error) > 1.62)
-	 {
-	    fprintf(stderr, "16bit %d ^ %f: got %d expected %f error %f\n",
-	       j, g, out, correct, error);
-	 }
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > 1.62)
+         {
+            fprintf(stderr, "16bit %d ^ %f: got %d expected %f error %f\n",
+               j, g, out, correct, error);
+         }
      }

      if (!silent)
-	 printf("gamma %f: maximum 16 bit error %f\n", g, maxerr);
+         printf("gamma %f: maximum 16 bit error %f\n", g, maxerr);
   }

   return 0;
--- a/contrib/libtests/timepng.c
+++ b/contrib/libtests/timepng.c
@@ -1,6 +1,6 @@
 /* timepng.c
 *
- * Copyright (c) 2012 John Cunningham Bowler
+ * Copyright (c) 2013 John Cunningham Bowler
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
 *
--- a/contrib/pngminim/decoder/makefile
+++ b/contrib/pngminim/decoder/makefile
@@ -14,7 +14,7 @@ LD=$(CC)
 RM=rm -f
 COPY=cp

-CFLAGS=-DPNG_USER_CONFIG -DNO_GZCOMPRESS -DNO_GZIP -I. -O1
+CFLAGS=-DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP -I. -O1

 C=.c
 O=.o
--- a/contrib/pngminim/decoder/pngusr.dfa
+++ b/contrib/pngminim/decoder/pngusr.dfa
@@ -1,6 +1,6 @@
 # pngminim/decoder/pngusr.dfa
 #
-# Copyright (c) 2010-2011 Glenn Randers-Pehrson
+# Copyright (c) 2010-2013 Glenn Randers-Pehrson
 #
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
--- a/contrib/pngminim/decoder/pngusr.h
+++ b/contrib/pngminim/decoder/pngusr.h
@@ -1,6 +1,6 @@
 /* minrdpngconf.h: headers to make a minimal png-read-only library
 *
- * Copyright (c) 2007, 2010-2011 Glenn Randers-Pehrson
+ * Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
 *
 * This code is released under the libpng license.
 * For conditions of distribution and use, see the disclaimer
--- a/contrib/pngminim/encoder/README
+++ b/contrib/pngminim/encoder/README
@@ -1,6 +1,6 @@
 This demonstrates the use of PNG_USER_CONFIG and pngusr.h

-The makefile builds a minimal write-only decoder with embedded libpng
+The makefile builds a minimal write-only encoder with embedded libpng
 and zlib.

 Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
--- a/contrib/pngminim/encoder/makefile
+++ b/contrib/pngminim/encoder/makefile
@@ -14,7 +14,7 @@ LD=$(CC)
 RM=rm -f
 COPY=cp

-CFLAGS=-DPNG_USER_CONFIG -DNO_GZIP -I. -O1
+CFLAGS=-DPNG_USER_CONFIG -DZ_SOLO -DNO_GZIP -I. -O1

 C=.c
 O=.o
--- a/contrib/pngminim/encoder/pngusr.dfa
+++ b/contrib/pngminim/encoder/pngusr.dfa
@@ -1,6 +1,6 @@
 # pngminim/encoder/pngusr.dfa
 #
-# Copyright (c) 2010-2011 Glenn Randers-Pehrson
+# Copyright (c) 2010-2013 Glenn Randers-Pehrson
 #
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
--- a/contrib/pngminim/encoder/pngusr.h
+++ b/contrib/pngminim/encoder/pngusr.h
@@ -1,6 +1,6 @@
 /* minwrpngconf.h: headers to make a minimal png-write-only library
 *
- * Copyright (c) 2007, 2010-2011 Glenn Randers-Pehrson
+ * Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
 *
 * This code is released under the libpng license.
 * For conditions of distribution and use, see the disclaimer
--- a/contrib/pngminim/preader/makefile
+++ b/contrib/pngminim/preader/makefile
@@ -30,7 +30,7 @@ XLIB = -L/usr/X11R6/lib -lX11
 #LIBS = $(XLIB)
 LIBS = $(XLIB) -lm                      #platforms that need libm

-CFLAGS=-DPNG_USER_CONFIG -DNO_GZCOMPRESS -DNO_GZIP -I. $(XINC) -O1
+CFLAGS=-DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP -I. $(XINC) -O1

 C=.c
 O=.o
--- a/contrib/pngminim/preader/pngusr.dfa
+++ b/contrib/pngminim/preader/pngusr.dfa
@@ -1,6 +1,6 @@
 # pngminim/preader/pngusr.dfa
 #
-# Copyright (c) 2010-2011 Glenn Randers-Pehrson
+# Copyright (c) 2010-2013 Glenn Randers-Pehrson
 #
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
--- a/contrib/pngminim/preader/pngusr.h
+++ b/contrib/pngminim/preader/pngusr.h
@@ -1,6 +1,6 @@
 /* minrdpngconf.h: headers to make a minimal png-read-only library
 *
- * Copyright (c) 2009, 2010-2011 Glenn Randers-Pehrson
+ * Copyright (c) 2009, 2010-2013 Glenn Randers-Pehrson
 *
 * This code is released under the libpng license.
 * For conditions of distribution and use, see the disclaimer
--- a/contrib/tools/checksum-icc.c
+++ b/contrib/tools/checksum-icc.c
@@ -1,6 +1,6 @@
 /* checksum-icc.c
 *
- * Copyright (c) 2012 John Cunningham Bowler
+ * Copyright (c) 2013 John Cunningham Bowler
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
 *
--- a/example.c
+++ b/example.c
@@ -3,7 +3,7 @@

 /* example.c - an example of using libpng
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Maintained 1998-2012 Glenn Randers-Pehrson
+ * Maintained 1998-2013 Glenn Randers-Pehrson
 * Maintained 1996, 1997 Andreas Dilger)
 * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
 * To the extent possible under law, the authors have waived
--- a/libpng-manual.txt
+++ b/libpng-manual.txt
@@ -1,9 +1,9 @@
 libpng-manual.txt - A description on how to use and modify libpng

- libpng version 1.6.0beta29 - September 4, 2012
+ libpng version 1.6.0rc03 - February 5, 2013
 Updated and distributed by Glenn Randers-Pehrson
 <glennrp at users.sourceforge.net>
- Copyright (c) 1998-2011 Glenn Randers-Pehrson
+ Copyright (c) 1998-2013 Glenn Randers-Pehrson

 This document is released under the libpng license.
 For conditions of distribution and use, see the disclaimer
@@ -11,9 +11,9 @@ libpng-manual.txt - A description on how to use and modify libpng

 Based on:

- libpng versions 0.97, January 1998, through 1.6.0beta29 - September 4, 2012
+ libpng versions 0.97, January 1998, through 1.6.0rc03 - February 5, 2013
 Updated and distributed by Glenn Randers-Pehrson
- Copyright (c) 1998-2011 Glenn Randers-Pehrson
+ Copyright (c) 1998-2013 Glenn Randers-Pehrson

 libpng 1.0 beta 6  version 0.96 May 28, 1997
 Updated and distributed by Andreas Dilger
@@ -67,7 +67,7 @@ of reducing the amount of time and effort it takes to support the PNG
 file format in application programs.

 The PNG specification (second edition), November 2003, is available as
-a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2003 (E)) at
+a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2004 (E)) at
 <http://www.w3.org/TR/2003/REC-PNG-20031110/
 The W3C and ISO documents have identical technical content.

@@ -675,9 +675,6 @@ where 0x7fffffffL means unlimited.  You can retrieve this limit with

   chunk_cache_max = png_get_chunk_cache_max(png_ptr);

-This limit also applies to the number of buffers that can be allocated
-by png_decompress_chunk() while decompressing iTXt, zTXt, and iCCP chunks.
-
 You can also set a limit on the amount of memory that a compressed chunk
 other than IDAT can occupy, with

@@ -2567,6 +2564,20 @@ You can #define PNG_ABORT() to a function that does something
 more useful than abort(), as long as your function does not
 return.

+Checking for invalid palette index on write was added at libpng
+1.5.10.  If a pixel contains an invalid (out-of-range) index libpng issues
+a benign error.  This is enabled by default because this condition is an
+error according to the PNG specification, Clause 11.3.2, but the error can
+be ignored in each png_ptr with
+
+   png_set_check_for_invalid_index(png_ptr, 0);
+
+If the error is ignored, or if png_benign_error() treats it as a warning,
+any invalid pixels are written as-is by the encoder, resulting in an
+invalid PNG datastream as output.  In this case the application is
+responsible for ensuring that the pixel indexes are in range when it writes
+a PLTE chunk with fewer entries than the bit depth would allow.
+
 Now you need to set up the output code.  The default for libpng is to
 use the C function fwrite().  If you use this, you will need to pass a
 valid FILE * in the function png_init_io().  Be sure that the file is
@@ -3069,8 +3080,8 @@ tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"),
 although this isn't a requirement.  Unlike the tIME chunk, the
 "Creation Time" tEXt chunk is not expected to be automatically changed
 by the software.  To facilitate the use of RFC 1123 dates, a function
-png_convert_to_rfc1123_buffer(buffer, png_timep) is provided to convert
-from PNG time to an RFC 1123 format string.  The caller must provide
+png_convert_to_rfc1123_buffer(png_ptr, buffer, png_timep) is provided to
+convert from PNG time to an RFC 1123 format string.  The caller must provide
 a writeable buffer of at least 29 bytes.

 Writing unknown chunks
@@ -3534,7 +3545,7 @@ need to write.  The "png_image" structure contains the following members:
   png_uint_32  warning_or_error;
   char         message[64];

-In the event of an error or warning the following field wrning_or_error
+In the event of an error or warning the following field warning_or_error
 field will be set to a non-zero value and the 'message' field will contain
 a '\0' terminated string with the libpng error or warning message.  If both
 warnings and an error were encountered, only the error is recorded.  If there
@@ -4562,13 +4573,30 @@ function) incorrectly returned a value of type png_uint_32.

 Checking for invalid palette index on read or write was added at libpng
 1.5.10.  When an invalid index is found, libpng issues a benign error.
-This is enabled by default but can be disabled in each png_ptr with
+This is enabled by default because this condition is an error according
+to the PNG specification, Clause 11.3.2, but the error can be ignored in
+each png_ptr with

   png_set_check_for_invalid_index(png_ptr, allowed);

      allowed  - one of
-                 0: disable
-                 1: enable
+                 0: disable benign error (accept the
+                    invalid data without warning).
+                 1: enable benign error (treat the
+                    invalid data as an error or a
+                    warning).
+
+If the error is ignored, or if png_benign_error() treats it as a warning,
+any invalid pixels are decoded as opaque black by the decoder and written
+as-is by the encoder.
+
+Retrieving the maximum palette index found was added at libpng-1.5.15.
+This statement must appear after png_read_png() or png_read_image().
+
+   int max_palette = png_get_palette_max(png_ptr, info_ptr);
+
+This will return the maximum palette index found, or "-1" if the palette
+was not checked, or "0" if no palette was found.

 A. Changes that affect users of libpng

@@ -4875,10 +4903,27 @@ how to do this, and a case where pngusr.h is still required.
 XII.  Changes to Libpng from version 1.5.x to 1.6.x

 A "simplified API" has been added (see documentation in png.h and a simple
-example in contrib/examples/pngtopng.c)
+example in contrib/examples/pngtopng.c).  The new publicly visible API
+includes the following:
+
+   macros:
+     PNG_FORMAT_*
+     PNG_IMAGE_*
+   structures:
+     png_control
+     png_image
+   read functions
+     png_image_begin_read_from_file()
+     png_image_begin_read_from_stdio()
+     png_image_begin_read_from_memory()
+     png_image_finish_read()
+     png_image_free()
+   write functions
+     png_image_write_to_file()
+     png_image_write_to_stdio()

 Starting with libpng-1.6.0, you can configure libpng to prefix all exported
-symbols.
+symbols, using the PNG_PREFIX macro.

 We no longer include string.h in png.h.  The include statement has been moved
 to pngpriv.h, where it is not accessible by applications.  Applications that
@@ -4890,8 +4935,10 @@ The following API are now DEPRECATED:
   png_info_init_3()
   png_convert_to_rfc1123() which has been replaced
     with png_convert_to_rfc1123_buffer()
+   png_data_freer()
   png_malloc_default()
   png_free_default()
+   png_reset_zstream()

 The following has been removed:
   png_get_io_chunk_name(), which has been replaced
@@ -4901,7 +4948,33 @@ The following has been removed:
   The png_sizeof(), png_strlen(), png_memcpy(), png_memcmp(), and
     png_memset() macros are no longer used in the libpng sources and
     have been removed.  These had already been made invisible to applications
-     since libpng-1.5.0.
+     (i.e., defined in the private pngpriv.h header file) since libpng-1.5.0.
+
+The signatures of many exported functions were changed, such that
+   png_structp became png_structrp or png_const_structrp
+   png_infop became png_inforp or png_const_inforp
+where "rp" indicates a "restricted pointer".
+
+Error detection in some chunks has improved; in particular the iCCP chunk
+reader now does pretty complete validation of the basic format.  Some bad
+profiles that were previously accepted are now rejected, in particular the
+very old broken Microsoft/HP sRGB profile.
+
+The library now issues a warning if both background processing and RGB to
+gray are used when gamma correction happens. As with previous versions of
+the library the results are numerically very incorrect in this case.
+
+There are some minor arithmetic changes in some transforms such as
+png_set_background(), that might be detected by certain regression tests.
+
+Unknown chunk handling has been improved internally, without any API change.
+This adds more correct option control of the unknown handling, corrects
+a pre-existing bug where the per-chunk 'keep' setting is ignored, and makes
+it possible to skip IDAT chunks in the sequential reader.
+
+The machine-generated configure files are no longer included in branches
+libpng16 and later of the GIT repository.  They continue to be included
+in the tarball releases, however.

 XIII.  Detecting libpng

@@ -5019,7 +5092,7 @@ pngtest) appear in
 pngpriv.h
 above the comment that says

-  /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
+  /* Maintainer: Put new private prototypes here ^ */

 We put a space after the "sizeof" operator and we omit the
 optional parentheses around its argument when the argument
@@ -5033,7 +5106,7 @@ Prior to libpng-1.6.0 we used a "png_sizeof()" macro, formatted as
 though it were a function.

 To avoid polluting the global namespace, the names of all exported
-functions and variables begin with  "png_", and all publicly visible C
+functions and variables begin with "png_", and all publicly visible C
 preprocessor macros begin with "PNG".  We request that applications that
 use libpng *not* begin any of their own symbols with either of these strings.

@@ -5047,7 +5120,7 @@ left parenthesis that follows it:
    for (i = 2; i > 0; --i)
       y[i] = a(x) + (int)b;

-We prefer #ifdef and #ifndef to #if defined() and if !defined()
+We prefer #ifdef and #ifndef to #if defined() and #if !defined()
 when there is only one macro being tested.

 We prefer to express integers that are used as bit masks in hex format,
@@ -5064,13 +5137,13 @@ Other rules can be inferred by inspecting the libpng source.

 XVI. Y2K Compliance in libpng

-September 4, 2012
+February 5, 2013

 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.6.0beta29 are Y2K compliant.  It is my belief that earlier
+upward through 1.6.0rc03 are Y2K compliant.  It is my belief that earlier
 versions were also Y2K compliant.

 Libpng only has two year fields.  One is a 2-byte unsigned integer
--- a/libpng.3
+++ b/libpng.3
--- a/libpngpf.3
+++ b/libpngpf.3
@@ -1,21 +1,11 @@
-.TH LIBPNGPF 3 "September 4, 2012"
+.TH LIBPNGPF 3 "February 5, 2013"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.6.0beta29
+libpng \- Portable Network Graphics (PNG) Reference Library 1.6.0rc03
 (private functions)
 .SH SYNOPSIS
 \fB#include \fI"pngpriv.h"

-\fI\fB
-
-\fBAs of libpng version \fP\fI1.5.1\fP\fB, this section is no longer \fP\fImaintained\fP\fB, now \fIthat
-
-\fBthe private function prototypes are hidden in pngpriv.h and not \fIaccessible
-
-\fBto applications. Look in pngpriv.h for the prototypes and a short \fIdescription
-
-\fBof each \fIfunction.
-
-\fI\fB
+\fBAs of libpng version \fP\fI1.5.1\fP\fB, this section is no longer \fP\fImaintained\fP\fB, now that the private function prototypes are hidden in pngpriv.h and not accessible to applications. Look in pngpriv.h for the prototypes and a short description of each \fIfunction.

 .SH DESCRIPTION
 The functions previously listed here are used privately by libpng and are not
--- a/png.5
+++ b/png.5
@@ -1,4 +1,4 @@
-.TH PNG 5 "September 4, 2012"
+.TH PNG 5 "February 5, 2013"
 .SH NAME
 png \- Portable Network Graphics (PNG) format
 .SH DESCRIPTION
--- a/png.c
+++ b/png.c
--- a/png.h
+++ b/png.h
@@ -1,8 +1,8 @@

 /* png.h - header file for PNG reference library
 *
- * libpng version 1.6.0beta29 - September 4, 2012
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * libpng version 1.6.0rc03 - February 5, 2013
+ * Copyright (c) 1998-2013 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.)
 *
@@ -11,7 +11,7 @@
 * 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.6.0beta29 - September 4, 2012: Glenn
+ *   libpng versions 0.97, January 1998, through 1.6.0rc03 - February 5, 2013: Glenn
 *   See also "Contributing Authors", below.
 *
 * Note about libpng version numbers:
@@ -166,7 +166,8 @@
 *    1.5.7beta01-05          15    10507  15.so.15.7[.0]
 *    1.5.7rc01-03            15    10507  15.so.15.7[.0]
 *    1.5.7                   15    10507  15.so.15.7[.0]
- *    1.6.0beta01-29          16    10600  16.so.16.0[.0]
+ *    1.6.0beta01-40          16    10600  16.so.16.0[.0]
+ *    1.6.0rc01-03            16    10600  16.so.16.0[.0]
 *
 *   Henceforth the source version will match the shared-library major
 *   and minor numbers; the shared-library major version number will be
@@ -198,8 +199,8 @@
 *
 * This code is released under the libpng license.
 *
- * libpng versions 1.2.6, August 15, 2004, through 1.6.0beta29, September 4, 2012, are
- * Copyright (c) 2004, 2006-2012 Glenn Randers-Pehrson, and are
+ * libpng versions 1.2.6, August 15, 2004, through 1.6.0rc03, February 5, 2013, are
+ * Copyright (c) 2004, 2006-2013 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:
 *
@@ -310,13 +311,13 @@
 * Y2K compliance in libpng:
 * =========================
 *
- *    September 4, 2012
+ *    February 5, 2013
 *
 *    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.6.0beta29 are Y2K compliant.  It is my belief that
+ *    upward through 1.6.0rc03 are Y2K compliant.  It is my belief that
 *    earlier versions were also Y2K compliant.
 *
 *    Libpng only has two year fields.  One is a 2-byte unsigned integer
@@ -376,9 +377,9 @@
 */

 /* Version information for png.h - this should match the version in png.c */
-#define PNG_LIBPNG_VER_STRING "1.6.0beta29"
+#define PNG_LIBPNG_VER_STRING "1.6.0rc03"
 #define PNG_HEADER_VERSION_STRING \
-     " libpng version 1.6.0beta29 - September 4, 2012\n"
+     " libpng version 1.6.0rc03 - February 5, 2013\n"

 #define PNG_LIBPNG_VER_SONUM   16
 #define PNG_LIBPNG_VER_DLLNUM  16
@@ -392,7 +393,7 @@
 * PNG_LIBPNG_VER_STRING, omitting any leading zero:
 */

-#define PNG_LIBPNG_VER_BUILD  29
+#define PNG_LIBPNG_VER_BUILD  03

 /* Release Status */
 #define PNG_LIBPNG_BUILD_ALPHA    1
@@ -409,7 +410,7 @@
 #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
                                       PNG_LIBPNG_BUILD_PRIVATE */

-#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_BETA
+#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_RC

 /* Careful here.  At one time, Guy wanted to use 082, but that would be octal.
 * We must not include leading zeros.
@@ -522,7 +523,7 @@ extern "C" {
 /* This triggers a compiler error in png.c, if png.c and png.h
 * do not agree upon the version number.
 */
-typedef char* png_libpng_version_1_6_0beta29;
+typedef char* png_libpng_version_1_6_0rc03;

 /* Basic control structions.  Read libpng-manual.txt or libpng.3 for more info.
 *
@@ -2182,7 +2183,7 @@ PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr,

 #ifdef PNG_hIST_SUPPORTED
 PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr,
-    png_const_inforp info_ptr, png_uint_16p *hist));
+    png_inforp info_ptr, png_uint_16p *hist));
 #endif

 #ifdef PNG_hIST_SUPPORTED
@@ -2214,7 +2215,7 @@ PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr,

 #ifdef PNG_pCAL_SUPPORTED
 PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr,
-    png_const_inforp info_ptr, png_charp *purpose, png_int_32 *X0,
+    png_inforp info_ptr, png_charp *purpose, png_int_32 *X0,
    png_int_32 *X1, int *type, int *nparams, png_charp *units,
    png_charpp *params));
 #endif
@@ -2237,7 +2238,7 @@ PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr,
 #endif

 PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr,
-   png_const_inforp info_ptr, png_colorp *palette, int *num_palette));
+   png_inforp info_ptr, png_colorp *palette, int *num_palette));

 PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr,
    png_inforp info_ptr, png_const_colorp palette, int num_palette));
@@ -2266,7 +2267,7 @@ PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr,

 #ifdef PNG_iCCP_SUPPORTED
 PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr,
-    png_const_inforp info_ptr, png_charpp name, int *compression_type,
+    png_inforp info_ptr, png_charpp name, int *compression_type,
    png_bytepp profile, png_uint_32 *proflen));
 #endif

@@ -2277,8 +2278,8 @@ PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
 #endif

 #ifdef PNG_sPLT_SUPPORTED
-PNG_EXPORT(160, png_uint_32, png_get_sPLT, (png_const_structrp png_ptr,
-    png_const_inforp info_ptr, png_sPLT_tpp entries));
+PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_sPLT_tpp entries));
 #endif

 #ifdef PNG_sPLT_SUPPORTED
@@ -2288,8 +2289,8 @@ PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,

 #ifdef PNG_TEXT_SUPPORTED
 /* png_get_text also returns the number of text chunks in *num_text */
-PNG_EXPORT(162, png_uint_32, png_get_text, (png_const_structrp png_ptr,
-    png_const_inforp info_ptr, png_textp *text_ptr, int *num_text));
+PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_textp *text_ptr, int *num_text));
 #endif

 /* Note while png_set_text() will accept a structure whose text,
@@ -2472,7 +2473,7 @@ PNG_EXPORT(175, void, png_set_unknown_chunk_location,
    (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location));

 PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr,
-    png_const_inforp info_ptr, png_unknown_chunkpp entries));
+    png_inforp info_ptr, png_unknown_chunkpp entries));
 #endif

 /* Png_free_data() will turn off the "valid" flag for anything it frees.
@@ -3202,6 +3203,8 @@ PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
    defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
 PNG_EXPORT(242, void, png_set_check_for_invalid_index,
    (png_structrp png_ptr, int allowed));
+PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
+    png_const_infop info_ptr));
 #endif

 /* Maintainer: Put new public prototypes here ^, in libpng.3, and project
@@ -3213,7 +3216,7 @@ PNG_EXPORT(242, void, png_set_check_for_invalid_index,
 * scripts/symbols.def as well.
 */
 #ifdef PNG_EXPORT_LAST_ORDINAL
-  PNG_EXPORT_LAST_ORDINAL(242);
+  PNG_EXPORT_LAST_ORDINAL(243);
 #endif

 #ifdef __cplusplus
--- a/pngconf.h
+++ b/pngconf.h
@@ -1,9 +1,9 @@

 /* pngconf.h - machine configurable file for libpng
 *
- * libpng version 1.6.0beta29 - September 4, 2012
+ * libpng version 1.6.0rc03 - February 5, 2013
 *
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -198,18 +198,16 @@
 * ==========================
 * This code is used at build time to find PNG_IMPEXP, the API settings
 * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL
- * import processing is possible.  On Windows/x86 systems it also sets
+ * import processing is possible.  On Windows systems it also sets
 * compiler-specific macros to the values required to change the calling
 * conventions of the various functions.
 */
-#if ( defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\
-      defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ) &&\
-    ( defined(_X86_) || defined(_X64_) || defined(_M_IX86) ||\
-      defined(_M_X64) || defined(_M_IA64) )
-  /* Windows system (DOS doesn't support DLLs) running on x86/x64.  Includes
-   * builds under Cygwin or MinGW.  Also includes Watcom builds but these need
-   * special treatment because they are not compatible with GCC or Visual C
-   * because of different calling conventions.
+#if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\
+    defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+  /* Windows system (DOS doesn't support DLLs).  Includes builds under Cygwin or
+   * MinGW on any architecture currently supported by Windows.  Also includes
+   * Watcom builds but these need special treatment because they are not
+   * compatible with GCC or Visual C because of different calling conventions.
   */
 #  if PNG_API_RULE == 2
    /* If this line results in an error, either because __watcall is not
@@ -223,6 +221,9 @@
 #  if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800))
 #    define PNGCAPI __cdecl
 #    if PNG_API_RULE == 1
+       /* If this line results in an error __stdcall is not understood and
+        * PNG_API_RULE should not have been set to '1'.
+        */
 #      define PNGAPI __stdcall
 #    endif
 #  else
@@ -260,7 +261,7 @@
 #    endif
 #  endif /* compiler */

-#else /* !Windows/x86 */
+#else /* !Windows */
 #  if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
 #    define PNGAPI _System
 #  else /* !Windows/x86 && !OS/2 */
--- a/pngerror.c
+++ b/pngerror.c
@@ -2,7 +2,7 @@
 /* pngerror.c - stub functions for i/o and memory allocation
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -163,7 +163,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
         case PNG_NUMBER_FORMAT_02u:
            /* Expects at least 2 digits. */
            mincount = 2;
-            /* fall through */
+            /* FALL THROUGH */

         case PNG_NUMBER_FORMAT_u:
            *--end = digits[number % 10];
@@ -173,7 +173,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
         case PNG_NUMBER_FORMAT_02x:
            /* This format expects at least two digits */
            mincount = 2;
-            /* fall through */
+            /* FALL THROUGH */

         case PNG_NUMBER_FORMAT_x:
            *--end = digits[number & 0xf];
@@ -510,6 +510,41 @@ png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
 #endif
 #endif /* PNG_READ_SUPPORTED */

+void /* PRIVATE */
+png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
+{
+   /* This is always supported, but for just read or just write it
+    * unconditionally does the right thing.
+    */
+#  if (defined PNG_READ_SUPPORTED) && (defined PNG_WRITE_SUPPORTED)
+      if (png_ptr->mode & PNG_IS_READ_STRUCT)
+#  endif
+
+#  ifdef PNG_READ_SUPPORTED
+      {
+         if (error < PNG_CHUNK_ERROR)
+            png_chunk_warning(png_ptr, message);
+
+         else
+            png_chunk_benign_error(png_ptr, message);
+      }
+#  endif
+
+#  if (defined PNG_READ_SUPPORTED) && (defined PNG_WRITE_SUPPORTED)
+      else if (!(png_ptr->mode & PNG_IS_READ_STRUCT))
+#  endif
+
+#  ifdef PNG_WRITE_SUPPORTED
+      {
+         if (error < PNG_CHUNK_WRITE_ERROR)
+            png_app_warning(png_ptr, message);
+
+         else
+            png_app_error(png_ptr, message);
+      }
+#  endif
+}
+
 #ifdef PNG_ERROR_TEXT_SUPPORTED
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 PNG_FUNCTION(void,
--- a/pngget.c
+++ b/pngget.c
@@ -2,7 +2,7 @@
 /* pngget.c - retrieval of values from info struct
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -701,7 +701,7 @@ png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,

 #ifdef PNG_iCCP_SUPPORTED
 png_uint_32 PNGAPI
-png_get_iCCP(png_const_structrp png_ptr, png_const_inforp info_ptr,
+png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
    png_charpp name, int *compression_type,
    png_bytepp profile, png_uint_32 *proflen)
 {
@@ -726,14 +726,14 @@ png_get_iCCP(png_const_structrp png_ptr, png_const_inforp info_ptr,
 #endif

 #ifdef PNG_sPLT_SUPPORTED
-png_uint_32 PNGAPI
-png_get_sPLT(png_const_structrp png_ptr, png_const_inforp info_ptr,
+int PNGAPI
+png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr,
    png_sPLT_tpp spalettes)
 {
   if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
   {
      *spalettes = info_ptr->splt_palettes;
-      return ((png_uint_32)info_ptr->splt_palettes_num);
+      return info_ptr->splt_palettes_num;
   }

   return (0);
@@ -742,7 +742,7 @@ png_get_sPLT(png_const_structrp png_ptr, png_const_inforp info_ptr,

 #ifdef PNG_hIST_SUPPORTED
 png_uint_32 PNGAPI
-png_get_hIST(png_const_structrp png_ptr, png_const_inforp info_ptr,
+png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr,
    png_uint_16p *hist)
 {
   png_debug1(1, "in %s retrieval function", "hIST");
@@ -818,7 +818,7 @@ png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr,

 #ifdef PNG_pCAL_SUPPORTED
 png_uint_32 PNGAPI
-png_get_pCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
+png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
    png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
    png_charp *units, png_charpp *params)
 {
@@ -938,7 +938,7 @@ png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr,
 #endif /* pHYs */

 png_uint_32 PNGAPI
-png_get_PLTE(png_const_structrp png_ptr, png_const_inforp info_ptr,
+png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr,
    png_colorp *palette, int *num_palette)
 {
   png_debug1(1, "in %s retrieval function", "PLTE");
@@ -974,8 +974,8 @@ png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
 #endif

 #ifdef PNG_TEXT_SUPPORTED
-png_uint_32 PNGAPI
-png_get_text(png_const_structrp png_ptr, png_const_inforp info_ptr,
+int PNGAPI
+png_get_text(png_const_structrp png_ptr, png_inforp info_ptr,
    png_textp *text_ptr, int *num_text)
 {
   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
@@ -989,7 +989,7 @@ png_get_text(png_const_structrp png_ptr, png_const_inforp info_ptr,
      if (num_text != NULL)
         *num_text = info_ptr->num_text;

-      return ((png_uint_32)info_ptr->num_text);
+      return info_ptr->num_text;
   }

   if (num_text != NULL)
@@ -1064,7 +1064,7 @@ png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr,

 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
 int PNGAPI
-png_get_unknown_chunks(png_const_structrp png_ptr, png_const_inforp info_ptr,
+png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
    png_unknown_chunkpp unknowns)
 {
   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
@@ -1161,4 +1161,15 @@ png_get_io_chunk_type (png_const_structrp png_ptr)
 }
 #endif /* ?PNG_IO_STATE_SUPPORTED */

+#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
+int PNGAPI
+png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)
+{
+   if (png_ptr != NULL && info_ptr != NULL)
+      return png_ptr->num_palette_max;
+
+   return (-1);
+}
+#endif
+
 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
--- a/pnginfo.h
+++ b/pnginfo.h
@@ -223,13 +223,17 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
   /* Storage for unknown chunks that the library doesn't recognize. */
   png_unknown_chunkp unknown_chunks;
-   unsigned int unknown_chunks_num;
+
+   /* The type of this field is limited by the type of 
+    * png_struct::user_chunk_cache_max, else overflow can occur.
+    */
+   int                unknown_chunks_num;
 #endif

 #ifdef PNG_sPLT_SUPPORTED
   /* Data on sPLT chunks (there may be more than one). */
   png_sPLT_tp splt_palettes;
-   png_uint_32 splt_palettes_num;
+   int         splt_palettes_num; /* Match type returned by png_get API */
 #endif

 #ifdef PNG_sCAL_SUPPORTED
--- a/pngmem.c
+++ b/pngmem.c
@@ -2,7 +2,7 @@
 /* pngmem.c - stub functions for memory allocation
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -76,7 +76,7 @@ png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
 #ifdef PNG_USER_MEM_SUPPORTED
   PNG_UNUSED(png_ptr)
 #endif
-   if (size > 0 && size <= ~(size_t)0
+   if (size > 0 && size <= PNG_SIZE_MAX
 #     ifdef PNG_MAX_MALLOC_64K
         && size <= 65536U
 #     endif
@@ -95,6 +95,68 @@ png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
      return NULL;
 }

+/* This is really here only to work round a spurious warning in GCC 4.6 and 4.7
+ * that arises because of the checks in png_realloc_array that are repeated in
+ * png_malloc_array.
+ */
+static png_voidp
+png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
+   size_t element_size)
+{
+   png_alloc_size_t req = nelements; /* known to be > 0 */
+
+   if (req <= PNG_SIZE_MAX/element_size)
+      return png_malloc_base(png_ptr, req * element_size);
+
+   /* The failure case when the request is too large */
+   return NULL;
+}
+
+PNG_FUNCTION(png_voidp /* PRIVATE */,
+png_malloc_array,(png_const_structrp png_ptr, int nelements,
+   size_t element_size),PNG_ALLOCATED)
+{
+   if (nelements <= 0 || element_size == 0)
+      png_error(png_ptr, "internal error: array alloc");
+
+   return png_malloc_array_checked(png_ptr, nelements, element_size);
+}
+
+PNG_FUNCTION(png_voidp /* PRIVATE */,
+png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
+   int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)
+{
+   /* These are internal errors: */
+   if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
+      (old_array == NULL && old_elements > 0))
+      png_error(png_ptr, "internal error: array realloc");
+
+   /* Check for overflow on the elements count (so the caller does not have to
+    * check.)
+    */
+   if (add_elements <= INT_MAX - old_elements)
+   {
+      png_voidp new_array = png_malloc_array_checked(png_ptr,
+         old_elements+add_elements, element_size);
+
+      if (new_array != NULL)
+      {
+         /* Because png_malloc_array worked the size calculations below cannot
+          * overflow.
+          */
+         if (old_elements > 0)
+            memcpy(new_array, old_array, element_size*(unsigned)old_elements);
+
+         memset((char*)new_array + element_size*(unsigned)old_elements, 0,
+            element_size*(unsigned)add_elements);
+
+         return new_array;
+      }
+   }
+
+   return NULL; /* error */
+}
+
 /* Various functions that have different error handling are derived from this.
 * png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate
 * function png_malloc_default is also provided.
--- a/pngpread.c
+++ b/pngpread.c
@@ -2,7 +2,7 @@
 /* pngpread.c - read a png file in push mode
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
--- a/pngpriv.h
+++ b/pngpriv.h
@@ -2,7 +2,7 @@
 /* pngpriv.h - private declarations for use inside libpng
 *
 * For conditions of distribution and use, see copyright notice in png.h
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -411,7 +411,7 @@ typedef const png_uint_16p * png_const_uint_16pp;
 #if PNG_ALIGN_TYPE == PNG_ALIGN_SIZE
   /* This is used because in some compiler implementations non-aligned
    * structure members are supported, so the offsetof approach below fails.
-    * Set PNG_ALIGN_TO_SIZE=0 for compiler combinations where unaligned access
+    * Set PNG_ALIGN_SIZE=0 for compiler combinations where unaligned access
    * is good for performance.  Do not do this unless you have tested the result
    * and understand it.
    */
@@ -757,6 +757,23 @@ PNG_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr,
 PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_base,(png_const_structrp png_ptr,
   png_alloc_size_t size),PNG_ALLOCATED);

+#if defined PNG_TEXT_SUPPORTED || defined PNG_sPLT_SUPPORTED ||\
+   defined PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+/* Internal array allocator, outputs no error or warning messages on failure,
+ * just returns NULL.  
+ */
+PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_array,(png_const_structrp png_ptr,
+   int nelements, size_t element_size),PNG_ALLOCATED);
+
+/* The same but an existing array is extended by add_elements.  This function
+ * also memsets the new elements to 0 and copies the old elements.  The old
+ * array is not freed or altered.
+ */
+PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_const_structrp png_ptr,
+   png_const_voidp array, int old_elements, int add_elements,
+   size_t element_size),PNG_ALLOCATED);
+#endif /* text, sPLT or unknown chunks */
+
 /* Magic to create a struct when there is no struct to call the user supplied
 * memory allocators.  Because error handling has not been set up the memory
 * handlers can't safely call png_error, but this is an obscure and undocumented
@@ -1406,9 +1423,12 @@ PNG_INTERNAL_FUNCTION(void,png_do_write_intrapixel,(png_row_infop row_info,

 /* Added at libpng version 1.6.0 */
 #ifdef PNG_GAMMA_SUPPORTED
-PNG_INTERNAL_FUNCTION(int,png_colorspace_set_gamma,(png_const_structrp png_ptr,
-    png_colorspacerp colorspace, png_fixed_point gAMA, int preferred),
-    PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_colorspace_set_gamma,(png_const_structrp png_ptr,
+    png_colorspacerp colorspace, png_fixed_point gAMA), PNG_EMPTY);
+   /* Set the colorspace gamma with a value provided by the application or by
+    * the gAMA chunk on read.  The value will override anything set by an ICC
+    * profile.
+    */

 PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr,
    png_inforp info_ptr), PNG_EMPTY);
@@ -1436,7 +1456,12 @@ PNG_INTERNAL_FUNCTION(int,png_colorspace_set_endpoints,

 #ifdef PNG_sRGB_SUPPORTED
 PNG_INTERNAL_FUNCTION(int,png_colorspace_set_sRGB,(png_const_structrp png_ptr,
-   png_colorspacerp colorspace, int intent, int preferred), PNG_EMPTY);
+   png_colorspacerp colorspace, int intent), PNG_EMPTY);
+   /* This does set the colorspace gAMA and cHRM values too, but doesn't set the
+    * flags to write them, if it returns false there was a problem and an error
+    * message has already been output (but the colorspace may still need to be
+    * synced to record the invalid flag).
+    */
 #endif /* sRGB */

 #ifdef PNG_iCCP_SUPPORTED
@@ -1459,15 +1484,15 @@ PNG_INTERNAL_FUNCTION(int,png_icc_check_tag_table,(png_const_structrp png_ptr,
   png_colorspacerp colorspace, png_const_charp name,
   png_uint_32 profile_length,
   png_const_bytep profile /* header plus whole tag table */), PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(int,png_icc_set_gAMA_and_cHRM,(
+#ifdef PNG_sRGB_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_icc_set_sRGB,(
   png_const_structrp png_ptr, png_colorspacerp colorspace,
-   png_const_charp name, png_const_bytep profile, uLong adler), PNG_EMPTY);
+   png_const_bytep profile, uLong adler), PNG_EMPTY);
   /* 'adler' is the Adler32 checksum of the uncompressed profile data. It may
    * be zero to indicate that it is not available.  It is used, if provided,
-    * as a fast check on the profile when checking to see if it is sRGB.  The
-    * result is false only if an error is detected in the profile; the routine
-    * may return true without actually setting cHRM and gAMA values.
+    * as a fast check on the profile when checking to see if it is sRGB.
    */
+#endif
 #endif /* iCCP */

 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
@@ -1598,6 +1623,21 @@ PNG_INTERNAL_FUNCTION(void,png_app_error,(png_const_structrp png_ptr,
 #  define png_app_error(pp,s) png_error(pp,s)
 #endif

+PNG_INTERNAL_FUNCTION(void,png_chunk_report,(png_const_structrp png_ptr,
+   png_const_charp message, int error),PNG_EMPTY);
+   /* Report a recoverable issue in chunk data.  On read this is used to report
+    * a problem found while reading a particular chunk and the
+    * png_chunk_benign_error or png_chunk_warning function is used as
+    * appropriate.  On write this is used to report an error that comes from
+    * data set via an application call to a png_set_ API and png_app_error or
+    * png_app_warning is used as appropriate.
+    *
+    * The 'error' parameter must have one of the following values:
+    */
+#define PNG_CHUNK_WARNING     0 /* never an error */
+#define PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */
+#define PNG_CHUNK_ERROR       2 /* always an error */
+
 /* ASCII to FP interfaces, currently only implemented if sCAL
 * support is required.
 */
@@ -1694,14 +1734,14 @@ PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
 #define PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK)
 #define PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK)

-/* The actual parser.  This can be called repeatedly, it updates
+/* The actual parser.  This can be called repeatedly. It updates
 * the index into the string and the state variable (which must
- * be initialzed to 0).  It returns a result code, as above.  There
+ * be initialized to 0).  It returns a result code, as above.  There
 * is no point calling the parser any more if it fails to advance to
 * the end of the string - it is stuck on an invalid character (or
 * terminated by '\0').
 *
- * Note that the pointer will consume an E or even an E+ then leave
+ * Note that the pointer will consume an E or even an E+ and then leave
 * a 'maybe' state even though a preceding integer.fraction is valid.
 * The PNG_FP_WAS_VALID flag indicates that a preceding substring was
 * a valid number.  It's possible to recover from this by calling
@@ -1839,7 +1879,16 @@ PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY);

 #endif /* SIMPLIFIED READ/WRITE */

-/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
+#ifdef PNG_FILTER_OPTIMIZATIONS
+PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
+   /* This is the initialization function for hardware specific optimizations,
+    * one implementation (for ARM NEON machines) is contained in
+    * arm/filter_neon.c.  It need not be defined - the generic code will be used
+    * if not.
+    */
+#endif
+
+/* Maintainer: Put new private prototypes here ^ */

 #include "pngdebug.h"

--- a/pngread.c
+++ b/pngread.c
@@ -2,7 +2,7 @@
 /* pngread.c - read a PNG file
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
--- a/pngrio.c
+++ b/pngrio.c
@@ -2,7 +2,7 @@
 /* pngrio.c - functions for data input
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
--- a/pngrtran.c
+++ b/pngrtran.c
@@ -2,7 +2,7 @@
 /* pngrtran.c - transforms the data in a row for PNG readers
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -1245,7 +1245,7 @@ png_init_rgb_transformations(png_structrp png_ptr)
            default:

            case 8:
-               /* Already 8 bits, fall through */
+               /* FALL THROUGH (Already 8 bits) */

            case 16:
               /* Already a full 16 bits */
@@ -3284,7 +3284,7 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)

      if (row_info->bit_depth == 8)
      {
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
         /* Notice that gamma to/from 1 are not necessarily inverses (if
          * there is an overall gamma correction).  Prior to 1.5.5 this code
          * checked the linearized values for equality; this doesn't match
@@ -3361,7 +3361,7 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)

      else /* RGB bit_depth == 16 */
      {
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
         if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_1 != NULL)
         {
            png_bytep sp = row;
@@ -3535,12 +3535,12 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
   png_const_uint_16pp gamma_16_from_1 = png_ptr->gamma_16_from_1;
   png_const_uint_16pp gamma_16_to_1 = png_ptr->gamma_16_to_1;
   int gamma_shift = png_ptr->gamma_shift;
+   int optimize = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0;
 #endif

   png_bytep sp;
   png_uint_32 i;
   png_uint_32 row_width = row_info->width;
-   int optimize = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0;
   int shift;

   png_debug(1, "in png_do_compose");
@@ -3968,7 +3968,7 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
                        *sp = (png_byte)png_ptr->background.gray;

                     else if (a < 0xff)
-                        png_composite(*sp, *sp, a, png_ptr->background_1.gray);
+                        png_composite(*sp, *sp, a, png_ptr->background.gray);
                  }
               }
            }
@@ -4037,7 +4037,7 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
                        png_uint_16 g, v;

                        g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-                        png_composite_16(v, g, a, png_ptr->background_1.gray);
+                        png_composite_16(v, g, a, png_ptr->background.gray);
                        *sp = (png_byte)((v >> 8) & 0xff);
                        *(sp + 1) = (png_byte)(v & 0xff);
                     }
--- a/pngrutil.c
+++ b/pngrutil.c
@@ -196,7 +196,7 @@ png_crc_read(png_structrp png_ptr, png_bytep buf, png_uint_32 length)
 }

 /* Optionally skip data and then check the CRC.  Depending on whether we
- * are reading a ancillary or critical chunk, and how the program has set
+ * are reading an ancillary or critical chunk, and how the program has set
 * things up, we may calculate the CRC on the data and print a message.
 * Returns '1' if there was a CRC error, '0' otherwise.
 */
@@ -282,7 +282,7 @@ png_crc_error(png_structrp png_ptr)

 /* Manage the read buffer; this simply reallocates the buffer if it is not small
 * enough (or if it is not allocated).  The routine returns a pointer to the
- * buffer, if an error occurs and 'warn' is set the routine returns NULL, else
+ * buffer; if an error occurs and 'warn' is set the routine returns NULL, else
 * it will call png_error (via png_malloc) on failure.  (warn == 2 means
 * 'silent').
 */
@@ -357,11 +357,11 @@ png_inflate_claim(png_structrp png_ptr, png_uint_32 owner, int window_bits)
   /* Implementation note: unlike 'png_deflate_claim' this internal function
    * does not take the size of the data as an argument.  Some efficiency could
    * be gained by using this when it is known *if* the zlib stream itself does
-    * not record the number, however this is a chimera: the original writer of
-    * the PNG may have selected a lower window size, and we really must follow
-    * that because, for systems with with limited capabilities, we would
-    * otherwise reject the applications attempts to use a smaller window size.
-    * (zlib doesn't have an interface to say "this or lower"!)
+    * not record the number; however, this is an illusion: the original writer
+    * of the PNG may have selected a lower window size, and we really must
+    * follow that because, for systems with with limited capabilities, we
+    * would otherwise reject the application's attempts to use a smaller window
+    * size (zlib doesn't have an interface to say "this or lower"!).
    *
    * inflateReset2 was added to zlib 1.2.4; before this the window could not be
    * reset, therefore it is necessary to always allocate the maximum window
@@ -1087,31 +1087,7 @@ png_handle_gAMA(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

   igamma = png_get_fixed_point(NULL, buf);

-   /* The gAMA value is unsigned (and is a power law correction, so 0 is
-    * meaningless.)
-    */
-   if (igamma <= 0)
-   {
-      png_chunk_benign_error(png_ptr, "out of range");
-      return;
-   }
-
-   /* If a colorspace error has already been output skip this chunk */
-   if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
-      return;
-
-   if (png_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA)
-   {
-      png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
-      png_colorspace_sync(png_ptr, info_ptr);
-
-      png_chunk_benign_error(png_ptr, "duplicate");
-      return;
-   }
-
-   png_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_gAMA;
-   (void)png_colorspace_set_gamma(png_ptr, &png_ptr->colorspace, igamma,
-      1/*prefer gAMA values*/);
+   png_colorspace_set_gamma(png_ptr, &png_ptr->colorspace, igamma);
   png_colorspace_sync(png_ptr, info_ptr);
 }
 #endif
@@ -1285,13 +1261,6 @@ png_handle_sRGB(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
   if (png_crc_finish(png_ptr, 0))
      return;

-   /* Check for bad intent */
-   if (intent >= PNG_sRGB_INTENT_LAST)
-   {
-      png_chunk_benign_error(png_ptr, "Unknown sRGB intent");
-      return;
-   }
-
   /* If a colorspace error has already been output skip this chunk */
   if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
      return;
@@ -1307,16 +1276,7 @@ png_handle_sRGB(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
      return;
   }

-   /* Do not override gAMA or cHRM from the PNG file; just check they match.
-    * This is because we write a cHRM which corresponds to D65, however there is
-    * an issue with CMMs that assume a D50 environment that requires adaptation
-    * of the white point.  This way at least it is possible to supply an
-    * adapated value (so long as it is within the tolerance limits for a match
-    * against the D65 chromaticities.)
-    *
-    * TODO: get expert opinions on this issue
-    */
-   (void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent, 0);
+   (void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent);
   png_colorspace_sync(png_ptr, info_ptr);
 }
 #endif /* PNG_READ_sRGB_SUPPORTED */
@@ -1475,8 +1435,6 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
                                 /* But otherwise allow extra data: */
                                 else if (size == 0)
                                 {
-                                    int ok;
-
                                    if (length > 0)
                                    {
                                       /* This can be handled completely, so
@@ -1489,16 +1447,15 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
                                    png_crc_finish(png_ptr, length);
                                    finished = 1;

-                                    /* Set the gAMA and cHRM information, this
-                                     * checks for a known sRGB profile.  The
-                                     * result is 0 on error.
-                                     */
-                                    ok = png_icc_set_gAMA_and_cHRM(png_ptr,
-                                       &png_ptr->colorspace, keyword, profile,
-                                       png_ptr->zstream.adler);
+#                                   ifdef PNG_sRGB_SUPPORTED
+                                       /* Check for a match against sRGB */
+                                       png_icc_set_sRGB(png_ptr,
+                                          &png_ptr->colorspace, profile,
+                                          png_ptr->zstream.adler);
+#                                   endif

                                    /* Steal the profile for info_ptr. */
-                                    if (ok && info_ptr != NULL)
+                                    if (info_ptr != NULL)
                                    {
                                       png_free_data(png_ptr, info_ptr,
                                          PNG_FREE_ICCP, 0);
@@ -1534,15 +1491,11 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
                                    if (info_ptr != NULL)
                                       png_colorspace_sync(png_ptr, info_ptr);

-                                    if (errmsg == NULL && ok)
+                                    if (errmsg == NULL)
                                    {
                                       png_ptr->zowner = 0;
                                       return;
                                    }
-
-                                    /* else png_icc_set_gAMA_and_cHRM has
-                                     * already output an error.
-                                     */
                                 }

                                 else if (size > 0)
@@ -3910,68 +3863,16 @@ png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row,
   }
 }

-#ifdef PNG_ARM_NEON
-
-#ifdef __linux__
-#include <stdio.h>
-#include <elf.h>
-#include <asm/hwcap.h>
-
-static int png_have_hwcap(unsigned cap)
-{
-   FILE *f = fopen("/proc/self/auxv", "r");
-   Elf32_auxv_t aux;
-   int have_cap = 0;
-
-   if (!f)
-      return 0;
-
-   while (fread(&aux, (sizeof aux), 1, f) > 0)
-   {
-      if (aux.a_type == AT_HWCAP &&
-          aux.a_un.a_val & cap)
-      {
-         have_cap = 1;
-         break;
-      }
-   }
-
-   fclose(f);
-
-   return have_cap;
-}
-#endif /* __linux__ */
-
-static void
-png_init_filter_functions_neon(png_structrp pp, unsigned int bpp)
-{
-#ifdef __linux__
-   if (!png_have_hwcap(HWCAP_NEON))
-      return;
-#endif
-
-   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_neon;
-
-   if (bpp == 3)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_neon;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_neon;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-         png_read_filter_row_paeth3_neon;
-   }
-
-   else if (bpp == 4)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_neon;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_neon;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-          png_read_filter_row_paeth4_neon;
-   }
-}
-#endif /* PNG_ARM_NEON */
-
 static void
 png_init_filter_functions(png_structrp pp)
+   /* This function is called once for every PNG image to set the
+    * implementations required to reverse the filtering of PNG rows.  Reversing
+    * the filter is the first transformation performed on the row data.  It is
+    * performed in place, therefore an implementation can be selected based on
+    * the image pixel format.  If the implementation depends on image width then
+    * take care to ensure that it works corretly if the image is interlaced -
+    * interlacing causes the actual row width to vary.
+    */
 {
   unsigned int bpp = (pp->pixel_depth + 7) >> 3;

@@ -3985,8 +3886,16 @@ png_init_filter_functions(png_structrp pp)
      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
         png_read_filter_row_paeth_multibyte_pixel;

-#ifdef PNG_ARM_NEON
-   png_init_filter_functions_neon(pp, bpp);
+#ifdef PNG_FILTER_OPTIMIZATIONS
+   /* To use this define PNG_FILTER_OPTIMIZATIONS as the name of a function to
+    * call to install hardware optimizations for the above functions; simply
+    * replace whatever elements of the pp->read_filter[] array with a hardware
+    * specific (or, for that matter, generic) optimization.
+    *
+    * To see an example of this examine what configure.ac does when
+    * --enable-arm-neon is specified on the command line.
+    */
+   PNG_FILTER_OPTIMIZATIONS(pp, bpp);
 #endif
 }

@@ -3994,6 +3903,10 @@ void /* PRIVATE */
 png_read_filter_row(png_structrp pp, png_row_infop row_info, png_bytep row,
   png_const_bytep prev_row, int filter)
 {
+   /* OPTIMIZATION: DO NOT MODIFY THIS FUNCTION, instead #define
+    * PNG_FILTER_OPTIMIZATIONS to a function that overrides the generic
+    * implementations.  See png_init_filter_functions above.
+    */
   if (pp->read_filter[0] == NULL)
      png_init_filter_functions(pp);
   if (filter > PNG_FILTER_VALUE_NONE && filter < PNG_FILTER_VALUE_LAST)
--- a/pngset.c
+++ b/pngset.c
@@ -2,7 +2,7 @@
 /* pngset.c - storage of image information into info struct
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -143,25 +143,8 @@ png_set_gAMA_fixed(png_const_structrp png_ptr, png_inforp info_ptr,
   if (png_ptr == NULL || info_ptr == NULL)
      return;

-   /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
-    * occur.  Since the fixed point representation is assymetrical it is
-    * possible for 1/gamma to overflow the limit of 21474 and this means the
-    * gamma value must be at least 5/100000 and hence at most 20000.0.  For
-    * safety the limits here are a little narrower.  The values are 0.00016 to
-    * 6250.0, which are truly ridiculous gamma values (and will produce
-    * displays that are all black or all white.)
-    */
-   if (file_gamma < 16 || file_gamma > 625000000)
-      png_app_error(png_ptr, "Out of range gamma value ignored");
-
-   else
-   {
-      if (png_colorspace_set_gamma(png_ptr, &info_ptr->colorspace, file_gamma,
-         2/* overrided with app value */))
-         info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_gAMA;
-
-      png_colorspace_sync_info(png_ptr, info_ptr);
-   }
+   png_colorspace_set_gamma(png_ptr, &info_ptr->colorspace, file_gamma);
+   png_colorspace_sync_info(png_ptr, info_ptr);
 }

 #  ifdef PNG_FLOATING_POINT_SUPPORTED
@@ -595,9 +578,7 @@ png_set_sRGB(png_const_structrp png_ptr, png_inforp info_ptr, int srgb_intent)
   if (png_ptr == NULL || info_ptr == NULL)
      return;

-   (void)png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent,
-      2/* app value overrides*/);
-
+   (void)png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent);
   png_colorspace_sync_info(png_ptr, info_ptr);
 }

@@ -610,10 +591,9 @@ png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr, png_inforp info_ptr,
   if (png_ptr == NULL || info_ptr == NULL)
      return;

-   if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent,
-      2/* app value overrides*/))
+   if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent))
   {
-      /* And cause the gAMA and cHRM to be written too */
+      /* This causes the gAMA and cHRM to be written too */
      info_ptr->colorspace.flags |=
         PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;
   }
@@ -716,63 +696,62 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
   png_debug1(1, "in %lx storage function", png_ptr == NULL ? "unexpected" :
      (unsigned long)png_ptr->chunk_name);

-   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
+   if (png_ptr == NULL || info_ptr == NULL || num_text <= 0 || text_ptr == NULL)
      return(0);

   /* Make sure we have enough space in the "text" array in info_struct
-    * to hold all of the incoming text_ptr objects.
+    * to hold all of the incoming text_ptr objects.  This compare can't overflow
+    * because max_text >= num_text (anyway, subtract of two positive integers
+    * can't overflow in any case.)
    */
-   if (info_ptr->num_text + num_text > info_ptr->max_text)
+   if (num_text > info_ptr->max_text - info_ptr->num_text)
   {
-      int old_max_text = info_ptr->max_text;
      int old_num_text = info_ptr->num_text;
+      int max_text;
+      png_textp new_text = NULL;

-      if (info_ptr->text != NULL)
+      /* Calculate an appropriate max_text, checking for overflow. */
+      max_text = old_num_text;
+      if (num_text <= INT_MAX - max_text)
      {
-         png_textp old_text;
+         max_text += num_text;

-         info_ptr->max_text = info_ptr->num_text + num_text + 8;
-         old_text = info_ptr->text;
+         /* Round up to a multiple of 8 */
+         if (max_text < INT_MAX-8)
+            max_text = (max_text + 8) & ~0x7;

-         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
-            (png_size_t)(info_ptr->max_text * (sizeof (png_text))));
+         else
+            max_text = INT_MAX;

-         if (info_ptr->text == NULL)
-         {
-            /* Restore to previous condition */
-            info_ptr->max_text = old_max_text;
-            info_ptr->text = old_text;
-            return(1);
-         }
-
-         memcpy(info_ptr->text, old_text, (png_size_t)(old_max_text *
-             (sizeof (png_text))));
-         png_free(png_ptr, old_text);
+         /* Now allocate a new array and copy the old members in, this does all
+          * the overflow checks.
+          */
+         new_text = png_voidcast(png_textp,png_realloc_array(png_ptr,
+            info_ptr->text, old_num_text, max_text-old_num_text,
+            sizeof *new_text));
      }

-      else
+      if (new_text == NULL)
      {
-         info_ptr->max_text = num_text + 8;
-         info_ptr->num_text = 0;
-         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
-             (png_size_t)(info_ptr->max_text * (sizeof (png_text))));
-         if (info_ptr->text == NULL)
-         {
-            /* Restore to previous condition */
-            info_ptr->num_text = old_num_text;
-            info_ptr->max_text = old_max_text;
-            return(1);
-         }
-         info_ptr->free_me |= PNG_FREE_TEXT;
+         png_chunk_report(png_ptr, "too many text chunks",
+            PNG_CHUNK_WRITE_ERROR);
+         return 1;
      }

-      png_debug1(3, "allocated %d entries for info_ptr->text",
-          info_ptr->max_text);
+      png_free(png_ptr, info_ptr->text);
+
+      info_ptr->text = new_text;
+      info_ptr->free_me |= PNG_FREE_TEXT;
+      info_ptr->max_text = max_text;
+      /* num_text is adjusted below as the entries are copied in */
+
+      png_debug1(3, "allocated %d entries for info_ptr->text", max_text);
   }
+
   for (i = 0; i < num_text; i++)
   {
-      png_size_t text_length, key_len;
-      png_size_t lang_len, lang_key_len;
+      size_t text_length, key_len;
+      size_t lang_len, lang_key_len;
      png_textp textp = &(info_ptr->text[info_ptr->num_text]);

      if (text_ptr[i].key == NULL)
@@ -781,7 +760,8 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
      if (text_ptr[i].compression < PNG_TEXT_COMPRESSION_NONE ||
          text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST)
      {
-         png_warning(png_ptr, "text compression mode is out of range");
+         png_chunk_report(png_ptr, "text compression mode is out of range",
+            PNG_CHUNK_WRITE_ERROR);
         continue;
      }

@@ -812,7 +792,8 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
      }
 #  else /* PNG_iTXt_SUPPORTED */
      {
-         png_warning(png_ptr, "iTXt chunk not supported");
+         png_chunk_report(png_ptr, "iTXt chunk not supported",
+            PNG_CHUNK_WRITE_ERROR);
         continue;
      }
 #  endif
@@ -835,19 +816,22 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
         textp->compression = text_ptr[i].compression;
      }

-      textp->key = (png_charp)png_malloc_warn(png_ptr,
-          (png_size_t)
-          (key_len + text_length + lang_len + lang_key_len + 4));
+      textp->key = png_voidcast(png_charp,png_malloc_base(png_ptr,
+          key_len + text_length + lang_len + lang_key_len + 4));

      if (textp->key == NULL)
-         return(1);
+      {
+         png_chunk_report(png_ptr, "text chunk: out of memory",
+               PNG_CHUNK_WRITE_ERROR);
+         return 1;
+      }

      png_debug2(2, "Allocated %lu bytes at %p in png_set_text",
          (unsigned long)(png_uint_32)
          (key_len + lang_len + lang_key_len + text_length + 4),
          textp->key);

-      memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
+      memcpy(textp->key, text_ptr[i].key, key_len);
      *(textp->key + key_len) = '\0';

      if (text_ptr[i].compression > 0)
@@ -869,8 +853,7 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
      }

      if (text_length)
-         memcpy(textp->text, text_ptr[i].text,
-             (png_size_t)(text_length));
+         memcpy(textp->text, text_ptr[i].text, text_length);

      *(textp->text + text_length) = '\0';

@@ -891,6 +874,7 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
      info_ptr->num_text++;
      png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
   }
+
   return(0);
 }
 #endif
@@ -994,78 +978,87 @@ png_set_sPLT(png_const_structrp png_ptr,
 */
 {
   png_sPLT_tp np;
-   int i;

-   if (png_ptr == NULL || info_ptr == NULL || nentries <= 0 ||
-      entries == NULL)
+   if (png_ptr == NULL || info_ptr == NULL || nentries <= 0 || entries == NULL)
      return;

-   np = png_voidcast(png_sPLT_tp, png_malloc_warn(png_ptr,
-       (info_ptr->splt_palettes_num + nentries) * (sizeof (png_sPLT_t))));
+   /* Use the internal realloc function, which checks for all the possible
+    * overflows.  Notice that the parameters are (int) and (size_t)
+    */
+   np = png_voidcast(png_sPLT_tp,png_realloc_array(png_ptr,
+      info_ptr->splt_palettes, info_ptr->splt_palettes_num, nentries,
+      sizeof *np));

   if (np == NULL)
   {
-      png_warning(png_ptr, "No memory for sPLT palettes");
+      /* Out of memory or too many chunks */
+      png_chunk_report(png_ptr, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR);
      return;
   }

-   memcpy(np, info_ptr->splt_palettes,
-       info_ptr->splt_palettes_num * (sizeof (png_sPLT_t)));
-
   png_free(png_ptr, info_ptr->splt_palettes);
-   info_ptr->splt_palettes=NULL;
+   info_ptr->splt_palettes = np;
+   info_ptr->free_me |= PNG_FREE_SPLT;

-   /* TODO: fix this, it apparently leaves NULL entries in the event of OOM
-    * below.
-    */
-   for (i = 0; i < nentries; i++)
+   np += info_ptr->splt_palettes_num;
+
+   do
   {
-      png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
-      png_const_sPLT_tp from = entries + i;
      png_size_t length;

-      /* In event of error below the name and entries fields must be set to
-       * NULL, otherwise libpng will crash later on while trying to free the
-       * uninitialized pointers.
+      /* Skip invalid input entries */
+      if (entries->name == NULL || entries->entries == NULL)
+      {
+         /* png_handle_sPLT doesn't do this, so this is an app error */
+         png_app_error(png_ptr, "png_set_sPLT: invalid sPLT");
+         /* Just skip the invalid entry */
+         continue;
+      }
+
+      np->depth = entries->depth;
+
+      /* In the even of out-of-memory just return - there's no point keeping on
+       * trying to add sPLT chunks.
       */
-      memset(to, 0, (sizeof *to));
+      length = strlen(entries->name) + 1;
+      np->name = png_voidcast(png_charp, png_malloc_base(png_ptr, length));

-      if (from->name == NULL || from->entries == NULL)
-         continue;
+      if (np->name == NULL)
+         break;

-      length = strlen(from->name) + 1;
-      to->name = png_voidcast(png_charp, png_malloc_warn(png_ptr, length));
+      memcpy(np->name, entries->name, length);

-      if (to->name == NULL)
+      /* IMPORTANT: we have memory now that won't get freed if something else
+       * goes wrong, this code must free it.  png_malloc_array produces no
+       * warnings, use a png_chunk_report (below) if there is an error.
+       */
+      np->entries = png_voidcast(png_sPLT_entryp, png_malloc_array(png_ptr,
+          entries->nentries, sizeof (png_sPLT_entry)));
+
+      if (np->entries == NULL)
      {
-         png_warning(png_ptr,
-             "Out of memory while processing sPLT chunk");
-         continue;
+         png_free(png_ptr, np->name);
+         break;
      }

-      memcpy(to->name, from->name, length);
-      to->entries = png_voidcast(png_sPLT_entryp, png_malloc_warn(png_ptr,
-          from->nentries * (sizeof (png_sPLT_entry))));
+      np->nentries = entries->nentries;
+      /* This multiply can't overflow because png_malloc_array has already
+       * checked it when doing the allocation.
+       */
+      memcpy(np->entries, entries->entries,
+         entries->nentries * sizeof (png_sPLT_entry));

-      if (to->entries == NULL)
-      {
-         png_warning(png_ptr, "Out of memory while processing sPLT chunk");
-         png_free(png_ptr, to->name);
-         to->name = NULL;
-         continue;
-      }
-
-      memcpy(to->entries, from->entries,
-          from->nentries * (sizeof (png_sPLT_entry)));
-
-      to->nentries = from->nentries;
-      to->depth = from->depth;
+      /* Note that 'continue' skips the advance of the out pointer and out
+       * count, so an invalid entry is not added.
+       */
+      info_ptr->valid |= PNG_INFO_sPLT;
+      ++(info_ptr->splt_palettes_num);
+      ++np;
   }
+   while (++entries, --nentries);

-   info_ptr->splt_palettes = np;
-   info_ptr->splt_palettes_num += nentries;
-   info_ptr->valid |= PNG_INFO_sPLT;
-   info_ptr->free_me |= PNG_FREE_SPLT;
+   if (nentries > 0)
+      png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR);
 }
 #endif /* PNG_sPLT_SUPPORTED */

@@ -1089,6 +1082,9 @@ check_location(png_const_structrp png_ptr, int location)
         (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT));
   }

+   /* This need not be an internal error - if the app calls
+    * png_set_unknown_chunks on a read pointer it must get the location right.
+    */
   if (location == 0)
      png_error(png_ptr, "invalid location in png_set_unknown_chunks");

@@ -1110,7 +1106,8 @@ png_set_unknown_chunks(png_const_structrp png_ptr,
 {
   png_unknown_chunkp np;

-   if (png_ptr == NULL || info_ptr == NULL || num_unknowns <= 0)
+   if (png_ptr == NULL || info_ptr == NULL || num_unknowns <= 0 ||
+      unknowns == NULL)
      return;

   /* Check for the failure cases where support has been disabled at compile
@@ -1136,20 +1133,21 @@ png_set_unknown_chunks(png_const_structrp png_ptr,
      }
 #  endif

-   /* Prior to 1.6.0 this code used png_malloc_warn, however this meant that
+   /* Prior to 1.6.0 this code used png_malloc_warn; however, this meant that
    * unknown critical chunks could be lost with just a warning resulting in
-    * undefined behavior.  Changing to png_malloc fixes this by producing a
-    * png_error.  The (png_size_t) cast was also removed as it hides a potential
-    * overflow.
-    *
-    * TODO: fix the potential overflow in the multiply
+    * undefined behavior.  Now png_chunk_report is used to provide behavior
+    * appropriate to read or write.
    */
-   np = png_voidcast(png_unknown_chunkp, png_malloc(png_ptr,
-       (info_ptr->unknown_chunks_num + (unsigned int)num_unknowns) *
-       (sizeof (png_unknown_chunk))));
+   np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr,
+         info_ptr->unknown_chunks, info_ptr->unknown_chunks_num, num_unknowns,
+         sizeof *np));

-   memcpy(np, info_ptr->unknown_chunks,
-       info_ptr->unknown_chunks_num * (sizeof (png_unknown_chunk)));
+   if (np == NULL)
+   {
+      png_chunk_report(png_ptr, "too many unknown chunks",
+         PNG_CHUNK_WRITE_ERROR);
+      return;
+   }

   png_free(png_ptr, info_ptr->unknown_chunks);
   info_ptr->unknown_chunks = np; /* safe because it is initialized */
@@ -1160,24 +1158,41 @@ png_set_unknown_chunks(png_const_structrp png_ptr,
   /* Increment unknown_chunks_num each time round the loop to protect the
    * just-allocated chunk data.
    */
-   for (; --num_unknowns >= 0;
-      ++np, ++unknowns, ++(info_ptr->unknown_chunks_num))
+   for (; num_unknowns > 0; --num_unknowns, ++unknowns)
   {
-      memcpy(np->name, unknowns->name, (sizeof unknowns->name));
+      memcpy(np->name, unknowns->name, (sizeof np->name));
      np->name[(sizeof np->name)-1] = '\0';
-      np->size = unknowns->size;
      np->location = check_location(png_ptr, unknowns->location);

      if (unknowns->size == 0)
+      {
         np->data = NULL;
+         np->size = 0;
+      }

      else
      {
-         /* png_error is safe here because the list is stored in png_ptr */
         np->data = png_voidcast(png_bytep,
-            png_malloc(png_ptr, unknowns->size));
+            png_malloc_base(png_ptr, unknowns->size));
+
+         if (np->data == NULL)
+         {
+            png_chunk_report(png_ptr, "unknown chunk: out of memory",
+               PNG_CHUNK_WRITE_ERROR);
+            /* But just skip storing the unknown chunk */
+            continue;
+         }
+
         memcpy(np->data, unknowns->data, unknowns->size);
+         np->size = unknowns->size;
      }
+
+      /* These increments are skipped on out-of-memory for the data - the
+       * unknown chunk entry gets overwritten if the png_chunk_report returns.
+       * This is correct in the read case (the chunk is just dropped.)
+       */
+      ++np;
+      ++(info_ptr->unknown_chunks_num);
   }
 }

@@ -1191,7 +1206,7 @@ png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr,
    * TODO: add a png_app_warning in 1.7
    */
   if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 &&
-      (unsigned int)chunk < info_ptr->unknown_chunks_num)
+      chunk < info_ptr->unknown_chunks_num)
   {
      if ((location & (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT)) == 0)
      {
@@ -1556,7 +1571,14 @@ png_set_benign_errors(png_structrp png_ptr, int allowed)
 #endif /* PNG_BENIGN_ERRORS_SUPPORTED */

 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
-   /* Do not report invalid palette index; added at libng-1.5.10 */
+   /* Whether to report invalid palette index; added at libng-1.5.10.
+    * It is possible for an indexed (color-type==3) PNG file to contain
+    * pixels with invalid (out-of-range) indexes if the PLTE chunk has
+    * fewer entries than the image's bit-depth would allow. We recover
+    * from this gracefully by filling any incomplete palette with zeroes
+    * (opaque black).  By default, when this occurs libpng will issue
+    * a benign error.  This API can be used to override that behavior.
+    */
 void PNGAPI
 png_set_check_for_invalid_index(png_structrp png_ptr, int allowed)
 {
@@ -1569,5 +1591,4 @@ png_set_check_for_invalid_index(png_structrp png_ptr, int allowed)
      png_ptr->num_palette_max = -1;
 }
 #endif
-
 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
--- a/pngstruct.h
+++ b/pngstruct.h
@@ -1,7 +1,7 @@

 /* pngstruct.h - header file for PNG reference library
 *
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -119,7 +119,6 @@ typedef struct png_colorspace
 #ifdef PNG_COLORSPACE_SUPPORTED
   png_xy      end_points_xy;    /* End points as chromaticities */
   png_XYZ     end_points_XYZ;   /* End points as CIE XYZ colorant values */
-   png_uint_32 icc_info;         /* Record of information from the colorspace */
   png_uint_16 rendering_intent; /* Rendering intent of a profile */
 #endif

@@ -129,82 +128,15 @@ typedef struct png_colorspace

 typedef const png_colorspace * PNG_RESTRICT png_const_colorspacerp;

-/* ICC specific flags for the 'icc_info' field. */
-/* The first four bits are for information defined from the profile, the
- * remainder of the bits indicate the presence of specific tags.  The #define
- * names are derived from the tag name in the ICC 2010 (v4) specification.
- */
-#  define PNG_ICC_PCSXYZ                 0x00000001U /* PCSXYS, else PCSLAB */
-#  define PNG_ICC_RGB                    0x00000002U /* 'RGB ', else 'GRAY ' */
-                                      /* 0x00000004U    reserved */
-                                      /* 0x00000008U    reserved */
-
-   /* A utility to return the number of channels on the A side of the transform
-    * given an info value (can be optimized).
-    */
-#  define PNG_ICC_CHANNELS(info) ((((info)&PNG_ICC_RGB)?2U:0U)+1U)
-
-   /* The profile description and copyright must be present in all valid ICC
-    * profiles, however libpng does not use them so absence is just reported as
-    * a warning.  The media white point should be present too, but if it isn't
-    * all we lose is the ability to know if it differs from the adapted white
-    * (i.e. the information that the device maxima are actually colored;
-    * a non-white substrate for a printer, or an uncorrected scan for example.)
-    * The chromaticAdaptationTag tells us that the adapted white of the original
-    * differs from the PCS adapted white (which is identical to the PCS
-    * illuminant and should always be D50).
-    */
-#  define PNG_ICC_profileDescriptionTag  0x00000010U /* required */
-#  define PNG_ICC_copyrightTag           0x00000020U /* required */
-#  define PNG_ICC_mediaWhitePointTag     0x00000040U /* required */
-#  define PNG_ICC_chromaticAdaptationTag 0x00000080U /* optional */
-
-   /* Tags that are required in all profiles (except DeviceLink): */
-#  define PNG_ICC_REQUIRED_BASE          0x00000070U
-
-   /* Other tags have to appear in specific profiles.  In general a profile must
-    * either contain appropriate TRC and (for RGB profiles) matrix tags *or* it
-    * must contain AToB0 and BToA0 - the CLUT based transforms to an absolute
-    * colorimetric PCS.  In the TRC case the PCS encoding must be PCSXYZ.
-    */
-#  define PNG_ICC_redMatrixColumnTag     0x00000100U
-#  define PNG_ICC_greenMatrixColumnTag   0x00000200U
-#  define PNG_ICC_blueMatrixColumnTag    0x00000400U
-                                      /* 0x00000800U    reserved */
-#  define PNG_ICC_redTRCTag              0x00001000U
-#  define PNG_ICC_greenTRCTag            0x00002000U
-#  define PNG_ICC_blueTRCTag             0x00004000U
-#  define PNG_ICC_grayTRCTag             0x00008000U
-#  define PNG_ICC_REQUIRED_RGB_MATRIXTRC 0x00007700U /* Required for RGB TRC */
-#  define PNG_ICC_ALL_TRC                0x0000f000U /* Includes all TRCTags */
-#  define PNG_ICC_REQUIRED_MATRIX        0x00000700U /* All MatrixColumnTags */
-
-#  define PNG_ICC_AToB0Tag               0x00010000U
-#  define PNG_ICC_BToA0Tag               0x00020000U
-#  define PNG_ICC_AToB1Tag               0x00040000U
-#  define PNG_ICC_BToA1Tag               0x00080000U
-#  define PNG_ICC_AToB2Tag               0x00100000U
-#  define PNG_ICC_BToA2Tag               0x00200000U
-#  define PNG_ICC_AToB_TAGS              0x00050000U /* Just AToB0 and AToB1 */
-#  define PNG_ICC_ALL_LUT                0x003f0000U
-                                      /* 0x00400000U    reserved */
-                                      /* 0x00800000U    reserved */
-
-   /* The ICC profile specification allows for shortcuts in the cHRM calculation
-    * via the colorant table (clrt) or the chromaticity tag (chrm).
-    */
-#  define PNG_ICC_chromaticityTag        0x01000000U
-#  define PNG_ICC_colorantTableTag       0x02000000U
-#  define PNG_ICC_gamutTag               0x04000000U
-
 /* General flags for the 'flags' field */
 #define PNG_COLORSPACE_HAVE_GAMMA           0x0001
 #define PNG_COLORSPACE_HAVE_ENDPOINTS       0x0002
 #define PNG_COLORSPACE_HAVE_INTENT          0x0004
 #define PNG_COLORSPACE_FROM_gAMA            0x0008
 #define PNG_COLORSPACE_FROM_cHRM            0x0010
-#define PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB 0x0020
-#define PNG_COLORSPACE_MATCHES_sRGB         0x0040 /* exact match on profile */
+#define PNG_COLORSPACE_FROM_sRGB            0x0020
+#define PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB 0x0040
+#define PNG_COLORSPACE_MATCHES_sRGB         0x0080 /* exact match on profile */
 #define PNG_COLORSPACE_INVALID              0x8000
 #define PNG_COLORSPACE_CANCEL(flags)        (0xffff ^ (flags))
 #endif /* COLORSPACE || GAMMA */
--- a/pngtest.c
+++ b/pngtest.c
@@ -2,7 +2,7 @@
 /* pngtest.c - a simple test program to test libpng
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -927,7 +927,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
       * changed with '--relaxed'.
       */
   }
-   
+
   else if (relaxed)
   {
      /* Allow application (pngtest) errors and warnings to pass */
@@ -1949,4 +1949,4 @@ main(void)
 #endif

 /* Generate a compiler error if there is an old png.h in the search path. */
-typedef png_libpng_version_1_6_0beta29 Your_png_h_is_not_version_1_6_0beta29;
+typedef png_libpng_version_1_6_0rc03 Your_png_h_is_not_version_1_6_0rc03;
--- a/pngtrans.c
+++ b/pngtrans.c
@@ -2,7 +2,7 @@
 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
--- a/pngwio.c
+++ b/pngwio.c
@@ -2,7 +2,7 @@
 /* pngwio.c - functions for data output
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
--- a/pngwrite.c
+++ b/pngwrite.c
@@ -2,7 +2,7 @@
 /* pngwrite.c - general routines to write a PNG file
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -447,7 +447,6 @@ png_write_end(png_structrp png_ptr, png_inforp info_ptr)
 }

 #ifdef PNG_CONVERT_tIME_SUPPORTED
-/* "tm" structure is not supported on WindowsCE */
 void PNGAPI
 png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)
 {
@@ -501,15 +500,19 @@ png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
    */
   png_ptr->zbuffer_size = PNG_ZBUF_SIZE;

-   png_ptr->zlib_strategy = Z_FILTERED; /* may be overridden if no filters */
-   png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;
+   /* The 'zlib_strategy' setting is irrelevant because png_default_claim in
+    * pngwutil.c defaults it according to whether or not filters will be used,
+    * and ignores this setting.
+    */
+   png_ptr->zlib_strategy = PNG_Z_DEFAULT_STRATEGY;
+   png_ptr->zlib_level = PNG_Z_DEFAULT_COMPRESSION;
   png_ptr->zlib_mem_level = 8;
   png_ptr->zlib_window_bits = 15;
   png_ptr->zlib_method = 8;

 #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
-   png_ptr->zlib_text_strategy = Z_DEFAULT_STRATEGY;
-   png_ptr->zlib_text_level = Z_DEFAULT_COMPRESSION;
+   png_ptr->zlib_text_strategy = PNG_TEXT_Z_DEFAULT_STRATEGY;
+   png_ptr->zlib_text_level = PNG_TEXT_Z_DEFAULT_COMPRESSION;
   png_ptr->zlib_text_mem_level = 8;
   png_ptr->zlib_text_window_bits = 15;
   png_ptr->zlib_text_method = 8;
@@ -936,7 +939,8 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
 #ifdef PNG_WRITE_FILTER_SUPPORTED
         case 5:
         case 6:
-         case 7: png_warning(png_ptr, "Unknown row filter for method 0");
+         case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
+            /* FALL THROUGH */
 #endif /* PNG_WRITE_FILTER_SUPPORTED */
         case PNG_FILTER_VALUE_NONE:
            png_ptr->do_filter = PNG_FILTER_NONE; break;
@@ -958,7 +962,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
            png_ptr->do_filter = (png_byte)filters; break;
 #else
         default:
-            png_warning(png_ptr, "Unknown row filter for method 0");
+            png_app_error(png_ptr, "Unknown row filter for method 0");
 #endif /* PNG_WRITE_FILTER_SUPPORTED */
      }

@@ -1595,7 +1599,7 @@ png_image_write_init(png_imagep image)
      png_destroy_write_struct(&png_ptr, NULL);
   }

-   return png_image_error(image, "png_image_read: out of memory");
+   return png_image_error(image, "png_image_write_: out of memory");
 }

 /* Arguments to png_image_write_main: */
@@ -2212,7 +2216,7 @@ png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
   const void *buffer, png_int_32 row_stride, const void *colormap)
 {
   /* Write the image to the given (FILE*). */
-   if (image != NULL || image->version != PNG_IMAGE_VERSION)
+   if (image != NULL && image->version == PNG_IMAGE_VERSION)
   {
      if (file != NULL)
      {
@@ -2262,7 +2266,7 @@ png_image_write_to_file(png_imagep image, const char *file_name,
   const void *colormap)
 {
   /* Write the image to the named file. */
-   if (image != NULL || image->version != PNG_IMAGE_VERSION)
+   if (image != NULL && image->version == PNG_IMAGE_VERSION)
   {
      if (file_name != NULL)
      {
--- a/pngwtran.c
+++ b/pngwtran.c
@@ -2,7 +2,7 @@
 /* pngwtran.c - transforms the data in a row for PNG writers
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
--- a/pngwutil.c
+++ b/pngwutil.c
@@ -2,7 +2,7 @@
 /* pngwutil.c - utilities to write a PNG file
 *
 * Last changed in libpng 1.6.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 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.)
 *
@@ -29,23 +29,6 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)
   buf[3] = (png_byte)(i & 0xff);
 }

-#ifdef PNG_SAVE_INT_32_SUPPORTED
-/* The png_save_int_32 function assumes integers are stored in two's
- * complement format.  If this isn't the case, then this routine needs to
- * be modified to write data in two's complement format.  Note that,
- * the following works correctly even if png_int_32 has more than 32 bits
- * (compare the more complex code required on read for sign extention.)
- */
-void PNGAPI
-png_save_int_32(png_bytep buf, png_int_32 i)
-{
-   buf[0] = (png_byte)((i >> 24) & 0xff);
-   buf[1] = (png_byte)((i >> 16) & 0xff);
-   buf[2] = (png_byte)((i >> 8) & 0xff);
-   buf[3] = (png_byte)(i & 0xff);
-}
-#endif
-
 /* Place a 16-bit number into a buffer in PNG byte order.
 * The parameter is declared unsigned int, not png_uint_16,
 * just to avoid potential problems on pre-ANSI C compilers.
@@ -355,10 +338,10 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
            strategy = png_ptr->zlib_strategy;

         else if (png_ptr->do_filter != PNG_FILTER_NONE)
-            strategy = Z_FILTERED;
+            strategy = PNG_Z_DEFAULT_STRATEGY;

         else
-            strategy = Z_DEFAULT_STRATEGY;
+            strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;
      }

      else
@@ -1444,7 +1427,8 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
   {
      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
      {
-         png_warning(png_ptr, "Invalid number of transparent colors specified");
+         png_app_warning(png_ptr,
+             "Invalid number of transparent colors specified");
         return;
      }

@@ -1458,7 +1442,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
      /* One 16 bit value */
      if (tran->gray >= (1 << png_ptr->bit_depth))
      {
-         png_warning(png_ptr,
+         png_app_warning(png_ptr,
             "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");

         return;
@@ -1480,7 +1464,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
      if (buf[0] | buf[2] | buf[4])
 #endif
      {
-         png_warning(png_ptr,
+         png_app_warning(png_ptr,
           "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
         return;
      }
@@ -1490,7 +1474,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,

   else
   {
-      png_warning(png_ptr, "Can't write tRNS with an alpha channel");
+      png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
   }
 }
 #endif
--- a/projects/vstudio/WARNING
+++ b/projects/vstudio/WARNING
@@ -0,0 +1,27 @@
+WARNING
+=======
+Libpng 1.6 does not use the default run-time library when building static
+library builds of libpng; instead of the shared DLL runtime it uses a static
+runtime.  If you need to change this make sure to change the setting on all the
+relevant projects:
+
+libpng
+zlib
+all the test programs
+
+The runtime library settings for each build are as follows:
+
+           Release        Debug
+DLL         /MD            /MDd
+Library     /MT            /MTd
+
+NOTICE that libpng 1.5 erroneously used /MD for Debug DLL builds; if you used
+the debug builds in your app and you changed your app to use /MD you will need
+to change it to /MDd for libpng 1.6.
+
+The Visual Studio 2010 defaults for a Win32 DLL or Static Library project are
+as follows:
+
+                 Release     Debug
+DLL               /MD         /MDd
+Static Library    /MD         /MDd
--- a/projects/vstudio/libpng/libpng.vcxproj
+++ b/projects/vstudio/libpng/libpng.vcxproj
@@ -23,8 +23,8 @@
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>libpng</RootNamespace>
  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <Import Project="$(SolutionDir)\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <CharacterSet>MultiByte</CharacterSet>
@@ -101,6 +101,7 @@
      <AdditionalIncludeDirectories>$(ZLibSrcDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
      <TreatWarningAsError>true</TreatWarningAsError>
      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
--- a/projects/vstudio/pnglibconf/pnglibconf.vcxproj
+++ b/projects/vstudio/pnglibconf/pnglibconf.vcxproj
@@ -17,6 +17,7 @@
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
+  <Import Project="$(SolutionDir)\zlib.props" />
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
--- a/projects/vstudio/pngstest/pngstest.vcxproj
+++ b/projects/vstudio/pngstest/pngstest.vcxproj
@@ -19,12 +19,12 @@
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
-    <ProjectGuid>{9B36B6FE-7FC0-434F-A71F-BBEF8099F1D8}</ProjectGuid>
+    <ProjectGuid>{277AC57F-313B-4D06-B119-A3CDB672D2FF}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>pngstest</RootNamespace>
  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <Import Project="$(SolutionDir)\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <CharacterSet>Unicode</CharacterSet>
@@ -91,11 +91,12 @@
      <FunctionLevelLinking>false</FunctionLevelLinking>
      <BrowseInformation>true</BrowseInformation>
      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
      <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
    </Link>
    <CustomBuildStep>
@@ -162,7 +163,7 @@
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
      <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
    </Link>
--- a/projects/vstudio/pngtest/pngtest.vcxproj
+++ b/projects/vstudio/pngtest/pngtest.vcxproj
@@ -23,8 +23,8 @@
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>pngtest</RootNamespace>
  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <Import Project="$(SolutionDir)\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <CharacterSet>Unicode</CharacterSet>
@@ -91,6 +91,7 @@
      <FunctionLevelLinking>false</FunctionLevelLinking>
      <BrowseInformation>true</BrowseInformation>
      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
--- a/projects/vstudio/pngunknown/pngunknown.vcxproj
+++ b/projects/vstudio/pngunknown/pngunknown.vcxproj
@@ -0,0 +1,219 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug Library|Win32">
+      <Configuration>Debug Library</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release Library|Win32">
+      <Configuration>Release Library</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>pngunknown</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <CustomBuildAfterTargets />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <CustomBuildAfterTargets />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <CustomBuildAfterTargets />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <CustomBuildAfterTargets />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <MinimalRebuild>false</MinimalRebuild>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;PNG_USE_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(ZLibSrcDir);..\..\..\scripts;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4996;4127</DisableSpecificWarnings>
+      <CompileAsManaged>false</CompileAsManaged>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <StringPooling>true</StringPooling>
+      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <BrowseInformation>true</BrowseInformation>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
+    </Link>
+    <CustomBuildStep>
+      <Message>Executing PNG validation program</Message>
+      <Command>"$(OutDir)pngunknown.exe" --strict --default --touch "$(IntDir)pngunknown.out" ../../../pngtest.png</Command>
+      <Outputs>$(IntDir)pngunknown.out</Outputs>
+      <Inputs>$(OutDir)pngunknown.exe</Inputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <MinimalRebuild>false</MinimalRebuild>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(ZLibSrcDir);..\..\..\scripts;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4996;4127</DisableSpecificWarnings>
+      <CompileAsManaged>false</CompileAsManaged>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <StringPooling>true</StringPooling>
+      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <BrowseInformation>true</BrowseInformation>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
+    </Link>
+    <CustomBuildStep>
+      <Message>Executing PNG validation program</Message>
+      <Command>"$(OutDir)pngunknown.exe" --strict --default --touch "$(IntDir)pngunknown.out" ../../../pngtest.png</Command>
+      <Outputs>$(IntDir)pngunknown.out</Outputs>
+      <Inputs>$(OutDir)pngunknown.exe</Inputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Full</Optimization>
+      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;PNG_USE_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(ZLibSrcDir);..\..\..\scripts;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4996;4127</DisableSpecificWarnings>
+      <CompileAsManaged>false</CompileAsManaged>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <StringPooling>true</StringPooling>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BrowseInformation>true</BrowseInformation>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CustomBuildStep>
+      <Message>Executing PNG validation program</Message>
+      <Command>"$(OutDir)pngunknown.exe" --strict --default --touch "$(IntDir)pngunknown.out" ../../../pngtest.png</Command>
+      <Outputs>$(IntDir)pngunknown.out</Outputs>
+      <Inputs>$(OutDir)pngunknown.exe</Inputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|Win32'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Full</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(ZLibSrcDir);..\..\..\scripts;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4996;4127</DisableSpecificWarnings>
+      <CompileAsManaged>false</CompileAsManaged>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <StringPooling>true</StringPooling>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BrowseInformation>true</BrowseInformation>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CustomBuildStep>
+      <Message>Executing PNG validation program</Message>
+      <Command>"$(OutDir)pngunknown.exe" --strict --default --touch "$(IntDir)pngunknown.out" ../../../pngtest.png</Command>
+      <Outputs>$(IntDir)pngunknown.out</Outputs>
+      <Inputs>$(OutDir)pngunknown.exe</Inputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\contrib\libtests\pngunknown.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
--- a/projects/vstudio/pngvalid/pngvalid.vcxproj
+++ b/projects/vstudio/pngvalid/pngvalid.vcxproj
@@ -23,8 +23,8 @@
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>pngvalid</RootNamespace>
  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <Import Project="$(SolutionDir)\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <CharacterSet>Unicode</CharacterSet>
@@ -91,6 +91,7 @@
      <FunctionLevelLinking>false</FunctionLevelLinking>
      <BrowseInformation>true</BrowseInformation>
      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
--- a/projects/vstudio/readme.txt
+++ b/projects/vstudio/readme.txt
@@ -1,7 +1,7 @@

 VisualStudio instructions

-libpng version 1.6.0beta29 - September 4, 2012
+libpng version 1.6.0rc03 - February 5, 2013

 Copyright (c) 1998-2010 Glenn Randers-Pehrson

@@ -33,8 +33,8 @@ optimization level (e.g. /Od.)
 Linking your application
 ========================
 Normally you should link against the 'release' configuration.  This builds a
-DLL for libpng 1.5 with the default runtime options used by Visual Studio
-2010.  In particular the runtime library is the "MultiThreaded DLL" version.
+DLL for libpng with the default runtime options used by Visual Studio 2010.
+In particular the runtime library is the "MultiThreaded DLL" version.
 If you use Visual Studio defaults to build your application you will have no
 problems.

@@ -58,7 +58,8 @@ Debug versions have limited support
 This solution includes limited support for debug versions of libpng.  You
 do not need these unless your own solution itself uses debug builds (it is
 far more effective to debug on the release builds, there is no point building
-a special debug build.)
+a special debug build unless you have heap corruption problems that you can't
+track down.)

 The debug build of libpng is minimally supported.  Support for debug builds of
 zlib is also minimal.  You really don't want to do this.
--- a/projects/vstudio/vstudio.sln
+++ b/projects/vstudio/vstudio.sln
@@ -1,5 +1,9 @@
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zlib", "zlib\zlib.vcxproj", "{60F89955-91C6-3A36-8000-13C592FEC2DF}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pnglibconf", "pnglibconf\pnglibconf.vcxproj", "{EB33566E-DA7F-4D28-9077-88C0B7C77E35}"
+EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libpng", "libpng\libpng.vcxproj", "{D6973076-9317-4EF2-A0B8-B7A18AC0713E}"
 	ProjectSection(ProjectDependencies) = postProject
 		{60F89955-91C6-3A36-8000-13C592FEC2DF} = {60F89955-91C6-3A36-8000-13C592FEC2DF}
@@ -13,8 +17,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pngtest", "pngtest\pngtest.
 		{D6973076-9317-4EF2-A0B8-B7A18AC0713E} = {D6973076-9317-4EF2-A0B8-B7A18AC0713E}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zlib", "zlib\zlib.vcxproj", "{60F89955-91C6-3A36-8000-13C592FEC2DF}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pngvalid", "pngvalid\pngvalid.vcxproj", "{9B36B6FE-7FC0-434F-A71F-BBEF8099F1D8}"
 	ProjectSection(ProjectDependencies) = postProject
 		{60F89955-91C6-3A36-8000-13C592FEC2DF} = {60F89955-91C6-3A36-8000-13C592FEC2DF}
@@ -22,8 +24,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pngvalid", "pngvalid\pngval
 		{D6973076-9317-4EF2-A0B8-B7A18AC0713E} = {D6973076-9317-4EF2-A0B8-B7A18AC0713E}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pnglibconf", "pnglibconf\pnglibconf.vcxproj", "{EB33566E-DA7F-4D28-9077-88C0B7C77E35}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pngstest", "pngstest\pngstest.vcxproj", "{277AC57F-313B-4D06-B119-A3CDB672D2FF}"
 	ProjectSection(ProjectDependencies) = postProject
 		{60F89955-91C6-3A36-8000-13C592FEC2DF} = {60F89955-91C6-3A36-8000-13C592FEC2DF}
@@ -31,6 +31,13 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pngstest", "pngstest\pngste
 		{D6973076-9317-4EF2-A0B8-B7A18AC0713E} = {D6973076-9317-4EF2-A0B8-B7A18AC0713E}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pngunknown", "pngunknown\pngunknown.vcxproj", "{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}"
+	ProjectSection(ProjectDependencies) = postProject
+		{60F89955-91C6-3A36-8000-13C592FEC2DF} = {60F89955-91C6-3A36-8000-13C592FEC2DF}
+		{EB33566E-DA7F-4D28-9077-88C0B7C77E35} = {EB33566E-DA7F-4D28-9077-88C0B7C77E35}
+		{D6973076-9317-4EF2-A0B8-B7A18AC0713E} = {D6973076-9317-4EF2-A0B8-B7A18AC0713E}
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug Library|Win32 = Debug Library|Win32
@@ -87,6 +94,14 @@ Global
 		{277AC57F-313B-4D06-B119-A3CDB672D2FF}.Release Library|Win32.Build.0 = Release Library|Win32
 		{277AC57F-313B-4D06-B119-A3CDB672D2FF}.Release|Win32.ActiveCfg = Release|Win32
 		{277AC57F-313B-4D06-B119-A3CDB672D2FF}.Release|Win32.Build.0 = Release|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Debug Library|Win32.ActiveCfg = Debug Library|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Debug Library|Win32.Build.0 = Debug Library|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Debug|Win32.Build.0 = Debug|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Release Library|Win32.ActiveCfg = Release Library|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Release Library|Win32.Build.0 = Release Library|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Release|Win32.ActiveCfg = Release|Win32
+		{C5D3156C-8C8C-4936-B35F-2B829BA36FEC}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
--- a/projects/vstudio/zlib.props
+++ b/projects/vstudio/zlib.props
@@ -2,7 +2,7 @@
 <!--
 * zlib.props - location of zlib source
 *
- * libpng version 1.6.0beta29 - September 4, 2012
+ * libpng version 1.6.0rc03 - February 5, 2013
 *
 * Copyright (c) 1998-2011 Glenn Randers-Pehrson
 *
@@ -33,5 +33,13 @@
 	 below:
     -->
    <ZLibSrcDir>..\..\..\..\zlib-1.2.5</ZLibSrcDir>
+
+    <!-- The following line allows compilation for an ARM target with Visual
+         Studio 2012.  Notice that this is not supported by the Visual Studio
+         2012 IDE and that the programs that result cannot be run unless they
+         signed by Microsoft.  This is therefore untested; only Microsoft can
+         test it:
+     -->
+    <WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>
  </PropertyGroup>
 </Project>
--- a/projects/vstudio/zlib/zlib.vcxproj
+++ b/projects/vstudio/zlib/zlib.vcxproj
@@ -32,10 +32,12 @@
    <ClCompile Include="$(ZLibSrcDir)\zutil.c" />
  </ItemGroup>
  <PropertyGroup Label="Globals">
+    <ProjectGuid>{60F89955-91C6-3A36-8000-13C592FEC2DF}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>zlib</RootNamespace>
  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <Import Project="$(SolutionDir)\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
  </PropertyGroup>
@@ -106,6 +108,7 @@
      <Optimization>Disabled</Optimization>
      <BrowseInformation>true</BrowseInformation>
      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
    </ClCompile>
    <Link>
      <TargetMachine>MachineX86</TargetMachine>
--- a/scripts/README.txt
+++ b/scripts/README.txt
@@ -1,9 +1,9 @@

-Makefiles for  libpng version 1.6.0beta29 - September 4, 2012
+Makefiles for  libpng version 1.6.0rc03 - February 5, 2013

 pnglibconf.h.prebuilt       =>  Stores configuration settings
 makefile.linux    =>  Linux/ELF makefile
-                       (gcc, creates libpng16.so.16.1.6.0beta29)
+                       (gcc, creates libpng16.so.16.1.6.0rc03)
 makefile.gcc      =>  Generic makefile (gcc, creates static libpng.a)
 makefile.knr      =>  Archaic UNIX Makefile that converts files with
                       ansi2knr (Requires ansi2knr.c from
@@ -20,7 +20,7 @@ pnglibconf.h.prebuilt       =>  Stores configuration settings
 makefile.dec      =>  DEC Alpha UNIX makefile
 makefile.dj2      =>  DJGPP 2 makefile
 makefile.elf      =>  Linux/ELF makefile symbol versioning,
-                       (gcc, creates libpng16.so.16.1.6.0beta29)
+                       (gcc, creates libpng16.so.16.1.6.0rc03)
 makefile.freebsd  =>  FreeBSD makefile
 makefile.gcc      =>  Generic gcc makefile
 makefile.hpgcc    =>  HPUX makefile using gcc
@@ -35,12 +35,12 @@ pnglibconf.h.prebuilt       =>  Stores configuration settings
 makefile.os2      =>  OS/2 Makefile (gcc and emx, requires libpng.def)
 makefile.sco      =>  For SCO OSr5  ELF and Unixware 7 with Native cc
 makefile.sggcc    =>  Silicon Graphics (gcc,
-                       creates libpng16.so.16.1.6.0beta29)
+                       creates libpng16.so.16.1.6.0rc03)
 makefile.sgi      =>  Silicon Graphics IRIX makefile (cc, creates static lib)
 makefile.solaris  =>  Solaris 2.X makefile (gcc,
-                       creates libpng16.so.16.1.6.0beta29)
+                       creates libpng16.so.16.1.6.0rc03)
 makefile.so9      =>  Solaris 9 makefile (gcc,
-                       creates libpng16.so.16.1.6.0beta29)
+                       creates libpng16.so.16.1.6.0rc03)
 makefile.std      =>  Generic UNIX makefile (cc, creates static libpng.a)
 makefile.sunos    =>  Sun makefile
 makefile.32sunu   =>  Sun Ultra 32-bit makefile
--- a/scripts/def.dfn
+++ b/scripts/def.dfn
@@ -25,7 +25,7 @@ S-OS2 DESCRIPTION "PNG image compression library"-E
 S-OS2 CODE PRELOAD MOVEABLE DISCARDABLE-E
 S--E
 S-EXPORTS-E
-S-;Version 1.5.0beta58-E
+S-;Version 1.6.0rc03-E

 /* NOTE: PNG_JOIN is interpreted by the calling script as a signal to
 * join the two things on either side, so we can do symbol
--- a/scripts/libpng-config-head.in
+++ b/scripts/libpng-config-head.in
@@ -11,7 +11,7 @@

 # Modeled after libxml-config.

-version=1.6.0beta29
+version=1.6.0rc03
 prefix=""
 libdir=""
 libs=""
--- a/scripts/libpng.pc.in
+++ b/scripts/libpng.pc.in
@@ -5,6 +5,6 @@ includedir=@includedir@/libpng16

 Name: libpng
 Description: Loads and saves PNG files
-Version: 1.6.0beta29
+Version: 1.6.0rc03
 Libs: -L${libdir} -lpng16
 Cflags: -I${includedir}
--- a/scripts/makefile.linux
+++ b/scripts/makefile.linux
@@ -236,4 +236,4 @@ pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h
 pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h             pnginfo.h pngdebug.h
 pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h             pnginfo.h pngdebug.h

-pngtest.o: png.h pngconf.h
+pngtest.o: png.h pngconf.h pnglibconf.h
--- a/scripts/makefile.msys
+++ b/scripts/makefile.msys
@@ -0,0 +1,204 @@
+# makefile for libpng using MSYS/gcc (shared, static library)
+# Copyright (C) 2012 Glenn Randers-Pehrson and Christopher M. Wheeler
+#
+# Portions taken from makefile.linux:
+# Copyright (C) 1998, 1999, 2002, 2006, 2008, 2010-2011 Greg Roelofs and
+# Glenn Randers-Pehrson
+# Copyright (C) 2000 Cosmin Truta
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+# # # # # # # # # # # # # # # # #
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+RELEASE = 0
+
+# Shared library names:
+LIBSO=$(LIBNAME).dll
+LIBSOMAJ=$(LIBNAME).dll.$(PNGMAJ)
+LIBSOREL=$(PNGMAJ).$(RELEASE)
+OLDSO=libpng.dll
+
+# Where the zlib library and include files are located.
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+ZLIBLIB=/usr/local/lib
+ZLIBINC=/usr/local/include
+
+# Compiler, linker, lib and other tools
+CC = gcc
+LD = $(CC)
+AR_RC = ar rcs
+RANLIB = ranlib
+RM_F = rm -rf
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+
+#ARCH = -march=pentium3
+#ARCH = -march=i686
+ARCH = 
+CDEBUG = -g -DPNG_DEBUG=5
+LDDEBUG =
+CRELEASE = -O2
+LDRELEASE = -s
+#CFLAGS = -W -Wall $(CDEBUG)
+CFLAGS = -W -Wall $(CRELEASE) $(ARCH)
+#LDFLAGS = $(LDDEBUG)
+LDFLAGS = $(LDRELEASE)
+LIBS = -lz -lm
+
+# File extensions
+O=.o
+A=.a
+EXE=.exe
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Variables
+OBJS =  png$(O) pngerror$(O) pngget$(O) pngmem$(O) pngpread$(O) \
+	pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) pngset$(O) \
+	pngtrans$(O) pngwio$(O) pngwrite$(O) pngwtran$(O) pngwutil$(O)
+
+# Targets
+all: static shared
+
+# see scripts/pnglibconf.mak for more options
+pnglibconf.h: scripts/pnglibconf.h.prebuilt
+	cp scripts/pnglibconf.h.prebuilt $@
+
+.c$(O):
+	$(CC) -c $(CFLAGS) -I$(ZLIBINC) $<
+
+static: libpng$(A) pngtest$(EXE)
+
+shared: $(LIBSOMAJ)
+	$(CC) -shared -Wl,-soname,$(LIBSOMAJ) -o $(LIBSO)
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ):
+	$(CC) -shared -Wl,-soname,$(LIBSOMAJ) -o $(LIBSOMAJ)
+
+libpng$(A): $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-Wl,-rpath,$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSO) $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+test: pngtest$(EXE)
+	./pngtest$(EXE)
+
+pngtest$(EXE): pngtest$(O) libpng$(A)
+	$(LD) $(LDFLAGS) -L$(ZLIBLIB) -o $@ pngtest$(O) libpng$(A) $(LIBS)
+
+clean:
+	$(RM_F) *$(O) libpng$(A) pngtest$(EXE) pngout.png pnglibconf.h $(LIBSO) \
+	$(LIBSOMAJ) libpng-config
+
+png$(O):      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread$(O):  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest$(O):  png.h pngconf.h pnglibconf.h
--- a/scripts/makefile.ne12bsd
+++ b/scripts/makefile.ne12bsd
@@ -17,7 +17,7 @@ INCSDIR=${LOCALBASE}/include/libpng16

 LIB=	png16
 SHLIB_MAJOR=	0
-SHLIB_MINOR=	1.6.0beta29
+SHLIB_MINOR=	1.6.0rc03
 SRCS=	png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
 	pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
 	pngwtran.c pngmem.c pngerror.c pngpread.c
--- a/scripts/makefile.netbsd
+++ b/scripts/makefile.netbsd
@@ -17,7 +17,7 @@ INCSDIR=${LOCALBASE}/include

 LIB=	png
 SHLIB_MAJOR=	16
-SHLIB_MINOR=	1.6.0beta29
+SHLIB_MINOR=	1.6.0rc03
 SRCS=	png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
 	pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
 	pngwtran.c pngmem.c pngerror.c pngpread.c
--- a/scripts/makefile.openbsd
+++ b/scripts/makefile.openbsd
@@ -11,7 +11,7 @@ LIBDIR=	${PREFIX}/lib
 MANDIR= ${PREFIX}/man/cat

 SHLIB_MAJOR=	16
-SHLIB_MINOR=	1.6.0beta29
+SHLIB_MINOR=	1.6.0rc03

 LIB=	png
 SRCS=	png.c pngerror.c pngget.c pngmem.c pngpread.c \
--- a/scripts/options.awk
+++ b/scripts/options.awk
@@ -102,6 +102,7 @@ pre && version == "search" && version_file != FILENAME{

 pre && version == "search" && $0 ~ /^ \* libpng version/{
   version = substr($0, 4)
+   gsub(/\./, " PNG_JOIN . PNG_JOIN", version)
   print "version =", version >out
   next
 }
--- a/scripts/pnglibconf.dfa
+++ b/scripts/pnglibconf.dfa
@@ -8,7 +8,7 @@ com pnglibconf.h - library build configuration
 com
 version
 com
-com Copyright (c) 1998-2011 Glenn Randers-Pehrson
+com Copyright (c) 1998-2012 Glenn Randers-Pehrson
 com
 com This code is released under the libpng license.
 com For conditions of distribution and use, see the disclaimer
@@ -147,6 +147,12 @@ logunsupported = 1
@#  endif
@#endif

+# IN DEVELOPMENT
+# These are currently experimental features; define them if you want (NOTE:
+# experimental options must be disabled before they are defined in this file!)
+
+# NONE
+
 # Note that PNG_USR_CONFIG only has an effect when building
 # pnglibconf.h

@@ -176,6 +182,22 @@ setting PREFIX

 setting DEFAULT_READ_MACROS default 1

+# These settings configure the default compression level (0-9) and 'strategy';
+# strategy is as defined by the implementors of zlib, it describes the input
+# data and modifies the zlib parameters in an attempt to optimize the balance
+# between search and huffman encoding in the zlib algorithms.  The defaults are
+# the zlib.h defaults - the apparently recursive definition does not arise
+# because the name of the setting is prefixed by PNG_
+#
+# The TEXT values are the defaults when writing compressed text (all forms)
+
+setting Z_DEFAULT_COMPRESSION default Z_DEFAULT_COMPRESSION
+setting Z_DEFAULT_STRATEGY default Z_FILTERED
+setting Z_DEFAULT_NOFILTER_STRATEGY default Z_DEFAULT_STRATEGY
+
+setting TEXT_Z_DEFAULT_COMPRESSION default Z_DEFAULT_COMPRESSION
+setting TEXT_Z_DEFAULT_STRATEGY default Z_DEFAULT_STRATEGY
+
 # The alternative is to call functions to read PNG values, if
 # the functions are turned *off* the read macros must always
 # be enabled, so turning this off will actually force the
@@ -319,6 +341,19 @@ option SAFE_LIMITS enables USER_LIMITS disabled
 # See the comments above about how to change options and settings.

 # READ options
+#
+# WARNING: in libpng 1.5 maintained configuration compatibility with earlier
+# versions.  In some cases turning off an option turned off other options, in
+# others it was ineffective unless dependent options were also turned off.
+# Libpng 1.6 changes this: in general if you turn off an option that affects
+# APIs it stays off and simply disables APIs that depend on it.
+#
+# As a result if you simply port the libpng 1.5 configuration to libpng 1.6 you
+# will probably see build failures due to missing APIs.  Fixing these failures
+# requires some, perhaps considerable, knowledge of what your libpng using
+# applications are doing, fortunately there is no great reason for you to move
+# to libpng 1.6; the new interfaces in 1.6 will take several years to become
+# popular.

 option READ enables READ_INTERLACING

@@ -336,27 +371,42 @@ option READ_QUANTIZE requires READ
 option READ_TRANSFORMS requires READ
 = NO_READ_TRANSFORMS READ_TRANSFORMS_NOT_SUPPORTED

-option READ_EXPAND requires READ_TRANSFORMS
-option READ_EXPAND_16 requires READ_TRANSFORMS READ_16BIT enables READ_EXPAND
-option READ_SHIFT requires READ_TRANSFORMS
-option READ_PACK requires READ_TRANSFORMS
-option READ_BGR requires READ_TRANSFORMS
-option READ_SWAP requires READ_TRANSFORMS READ_16BIT
-option READ_PACKSWAP requires READ_TRANSFORMS
-option READ_INVERT requires READ_TRANSFORMS
-option READ_BACKGROUND requires READ_TRANSFORMS enables READ_STRIP_ALPHA
-option READ_STRIP_16_TO_8 requires READ_TRANSFORMS
-option READ_SCALE_16_TO_8 requires READ_TRANSFORMS
-option READ_FILLER requires READ_TRANSFORMS
-option READ_GAMMA requires READ_TRANSFORMS enables READ_gAMA
-option READ_GRAY_TO_RGB requires READ_TRANSFORMS
+# Read gamma handling.  Gamma processing is a core part of libpng and many of
+# the capabilities are dependent on libpng performing gamma correction.
+#
+# In libpng 1.6 disabling gamma processing (setting PNG_NO_READ_GAMMA)
+# consistently disables those parts of the API that depend on it.  Prior to
+# 1.6.0 this was not true; the results were unpredictable and varied between
+# releases.
+#
+# If you disable gamma processing and your program no longer compiles you need
+# to ask whether you really need the APIs that are missing.  If you do then you
+# almost certainly need the gamma processing.
+#
+# If you handle gamma issues outside libpng then you do not need the libpng
+# gamma processing; and it is an enormous waste of space.  You just need to
+# remove the use of libpng APIs that depend on it.
+option READ_GAMMA requires READ_TRANSFORMS READ_gAMA

-option READ_ALPHA_MODE requires READ_TRANSFORMS enables READ_GAMMA
-option READ_SWAP_ALPHA requires READ_TRANSFORMS
+option READ_ALPHA_MODE requires READ_TRANSFORMS READ_GAMMA
+option READ_BACKGROUND requires READ_TRANSFORMS READ_STRIP_ALPHA READ_GAMMA
+option READ_BGR requires READ_TRANSFORMS
+option READ_EXPAND_16 requires READ_TRANSFORMS READ_16BIT READ_EXPAND
+option READ_EXPAND requires READ_TRANSFORMS
+option READ_FILLER requires READ_TRANSFORMS
+option READ_GRAY_TO_RGB requires READ_TRANSFORMS
 option READ_INVERT_ALPHA requires READ_TRANSFORMS
+option READ_INVERT requires READ_TRANSFORMS
+option READ_PACK requires READ_TRANSFORMS
+option READ_PACKSWAP requires READ_TRANSFORMS
+option READ_RGB_TO_GRAY requires READ_TRANSFORMS READ_GAMMA
+option READ_SCALE_16_TO_8 requires READ_TRANSFORMS
+option READ_SHIFT requires READ_TRANSFORMS
+option READ_STRIP_16_TO_8 requires READ_TRANSFORMS
 option READ_STRIP_ALPHA requires READ_TRANSFORMS
+option READ_SWAP_ALPHA requires READ_TRANSFORMS
+option READ_SWAP requires READ_TRANSFORMS READ_16BIT
 option READ_USER_TRANSFORM requires READ_TRANSFORMS
-option READ_RGB_TO_GRAY requires READ_TRANSFORMS

 option PROGRESSIVE_READ requires READ
 option SEQUENTIAL_READ requires READ
@@ -380,11 +430,6 @@ option INCH_CONVERSIONS

 option BUILD_GRAYSCALE_PALETTE

-# IN DEVELOPMENT
-# These are currently experimental features; define them if you want
-
-# NOTHING HERE
-
 # WRITE options

 option WRITE
@@ -694,9 +739,10 @@ option CONVERT_tIME requires WRITE_ANCILLARY_CHUNKS

 option WRITE_FILTER requires WRITE

-option SAVE_INT_32 requires WRITE
-
-# png_save_int_32 is required by the ancillary chunks oFFs and pCAL
+option SAVE_INT_32 disabled
+# png_save_int_32 is required internally for writing the ancillary chunks oFFs
+# and pCAL and for both reading and writing iCCP (for the generation/checking of
+# the corresponding cHRM/gAMA chunks) if full ICC is supported.

 # added at libpng-1.5.4

@@ -734,7 +780,7 @@ option WRITE_CHECK_FOR_INVALID_INDEX requires WRITE CHECK_FOR_INVALID_INDEX
 # Simplified API options (added at libpng-1.6.0)
 # Read:
 option SIMPLIFIED_READ requires SEQUENTIAL_READ READ_TRANSFORMS SETJMP
-option SIMPLIFIED_READ requires BENIGN_ERRORS
+option SIMPLIFIED_READ requires BENIGN_ERRORS READ_GAMMA
 option SIMPLIFIED_READ enables READ_EXPAND READ_16BIT READ_EXPAND_16
 option SIMPLIFIED_READ enables READ_SCALE_16_TO_8 READ_RGB_TO_GRAY
 option SIMPLIFIED_READ enables READ_ALPHA_MODE READ_BACKGROUND READ_STRIP_ALPHA
--- a/scripts/pnglibconf.h.prebuilt
+++ b/scripts/pnglibconf.h.prebuilt
@@ -3,9 +3,9 @@

 /* pnglibconf.h - library build configuration */

-/* Libpng 1.6.0beta29 - September 4, 2012 */
+/* Libpng 1.6.0rc03 - February 5, 2013 */

-/* Copyright (c) 1998-2012 Glenn Randers-Pehrson */
+/* Copyright (c) 1998-2013 Glenn Randers-Pehrson */

 /* This code is released under the libpng license. */
 /* For conditions of distribution and use, see the disclaimer */
@@ -34,8 +34,13 @@
 #define PNG_QUANTIZE_RED_BITS 5
 #define PNG_sCAL_PRECISION 5
 #define PNG_sRGB_PROFILE_CHECKS 2
+#define PNG_TEXT_Z_DEFAULT_COMPRESSION Z_DEFAULT_COMPRESSION
+#define PNG_TEXT_Z_DEFAULT_STRATEGY Z_DEFAULT_STRATEGY
 #define PNG_WEIGHT_SHIFT 8
 #define PNG_ZBUF_SIZE 8192
+#define PNG_Z_DEFAULT_COMPRESSION Z_DEFAULT_COMPRESSION
+#define PNG_Z_DEFAULT_NOFILTER_STRATEGY Z_DEFAULT_STRATEGY
+#define PNG_Z_DEFAULT_STRATEGY Z_FILTERED
 /* end of settings */
 /* options */
 #define PNG_16BIT_SUPPORTED
--- a/scripts/symbols.def
+++ b/scripts/symbols.def
@@ -5,7 +5,7 @@
 LIBRARY

 EXPORTS
-;Version 1.6.0beta29
+;Version 1.6.0rc03
 png_access_version_number @1
 png_set_sig_bytes @2
 png_sig_cmp @3
@@ -205,7 +205,6 @@ EXPORTS
 png_get_y_offset_inches @197
 png_get_pHYs_dpi @198
 png_get_io_state @199
-;png_get_io_chunk_name @200
 png_get_uint_32 @201
 png_get_uint_16 @202
 png_get_int_32 @203
@@ -248,3 +247,4 @@ EXPORTS
 png_image_write_to_stdio @240
 png_convert_to_rfc1123_buffer @241
 png_set_check_for_invalid_index @242
+ png_get_palette_max @243
Author	SHA1	Message	Date
Glenn Randers-Pehrson	777044a856	[libpng16] Imported from libpng-1.6.0rc03.tar	2013-02-05 10:34:11 -06:00
John Bowler	fe5c8b9755	[libpng16] Fixed palette_max API.	2013-02-05 08:01:09 -06:00
Glenn Randers-Pehrson	8d391c6cea	[libpng16] Bump version to 1.6.0rc03	2013-02-04 20:43:27 -06:00
Glenn Randers-Pehrson	32d6a74293	[libpng16] Imported from libpng-1.6.0rc02.tar	2013-02-04 20:12:49 -06:00
Glenn Randers-Pehrson	806477742a	[libpng16] Added documentation of the new png_get_palette_max() function.	2013-02-04 19:57:32 -06:00
Glenn Randers-Pehrson	29890b0439	[libpng16] Imported from libpng-1.6.0rc01.tar	2013-01-26 12:13:17 -06:00
Glenn Randers-Pehrson	9f860f59d9	[libpng16] Bump version to 1.6.0beta41	2013-01-20 17:32:13 -06:00
Glenn Randers-Pehrson	f8aa57e791	[libpng16] Imported from libpng-1.6.0beta40.tar	2013-01-20 17:25:00 -06:00
Glenn Randers-Pehrson	4567935fe4	[libpng16] Push two files that weren't updated in previous push.	2013-01-20 00:44:29 -06:00
John Bowler	2414bd99d8	[libpng16] Use consistent handling of overflows in text, sPLT and unknown png_set_* APIs	2013-01-19 23:18:59 -06:00
Glenn Randers-Pehrson	1f76e62d6c	[libpng16] Bump version to 1.6.0beta40	2013-01-19 08:57:40 -06:00
Glenn Randers-Pehrson	e208108dfc	[libpng16] Imported from libpng-1.6.0beta39.tar	2013-01-19 08:50:15 -06:00
Glenn Randers-Pehrson	590c8b0987	[libpng16] Added overflow detection in png_set_sPLT() and png_set_text_2().	2013-01-19 08:49:12 -06:00
Glenn Randers-Pehrson	c5c8b542fb	[libpng16] Bump version to 1.6.0beta39	2013-01-17 13:57:58 -06:00
Glenn Randers-Pehrson	91a7ad9d2b	[libpng16] Imported from libpng-1.6.0beta38.tar	2013-01-17 13:57:42 -06:00
John Bowler	9dd2bfafe5	[libpng16] Corrected previous attempt at overflow detection in png_set_unknown_chunks().	2013-01-17 13:24:05 -06:00
Glenn Randers-Pehrson	ba35f1e4c1	[libpng16] Bump version to 1.6.0beta38	2013-01-10 12:21:07 -06:00
Glenn Randers-Pehrson	5851280929	[libpng16] Imported from libpng-1.6.0beta37.tar	2013-01-10 12:20:59 -06:00
John Bowler	1c6e22a360	[libpng16] Fixed conceivable but difficult to repro overflow. Also added two test programs to generate and test a PNG which should have the problem.	2013-01-10 10:55:34 -06:00
Glenn Randers-Pehrson	37109a9f5b	[libpng16] Bump version to 1.6.0beta37	2013-01-01 08:40:25 -06:00
Glenn Randers-Pehrson	a70216aa60	[libpng16] Imported from libpng-1.6.0beta36.tar	2013-01-01 08:40:16 -06:00
Glenn Randers-Pehrson	9477ecdfa6	[libpng16] Updated copyright year to 2013 in newly-changed files	2013-01-01 07:45:42 -06:00
John Bowler	408652acaf	[libpng16] Fixed 'make distcheck' on SUN OS - libpng.so was not being removed	2012-12-27 09:56:41 -06:00
Glenn Randers-Pehrson	744f041adf	[libpng16] Discontinued distributing libpng-1.x.x.tar.bz2. Discontinued distributing libpng-1.7.0-1.6.0-diff.txt and similar.	2012-12-23 22:19:43 -06:00
Glenn Randers-Pehrson	86c739e8bc	[libpng16] Bump version to 1.6.0beta36	2012-12-22 18:34:22 -06:00
Glenn Randers-Pehrson	00634fdac8	[libpng16] Imported from libpng-1.6.0beta35.tar	2012-12-22 18:34:13 -06:00
Glenn Randers-Pehrson	79ee877fb4	[libpng16] Reformatted latest CHANGES/ANNOUNCE entry to 80 character lines.	2012-12-22 17:13:35 -06:00
John Bowler	e9d616321a	[libpng16] Fixed Windows build issues, enabled ARM compilation. Various warnings issued by earlier versions of GCC fixed for Cygwin and Min/GW (which both use old GCCs.) ARM support is enabled by default in zlib.props (unsupported by Microsoft) and ARM compilation is made possible by deleting the check for x86. The test programs cannot be run because they are not signed.	2012-12-20 22:48:58 -06:00
John Bowler	24639a63ce	[libpng16] Made default Zlib compression settings be configurable. This adds #defines to pnglibconf.h to control the defaults.	2012-12-20 22:26:18 -06:00
Glenn Randers-Pehrson	5362c9d5e5	[libpng16] Bump version to 1.6.0beta35	2012-12-19 16:21:35 -06:00
Glenn Randers-Pehrson	b6bfd40da2	[libpng16] Imported from libpng-1.6.0beta34.tar	2012-12-19 16:12:30 -06:00
Glenn Randers-Pehrson	a1d32d08e1	[libpng16] ANNOUNCE that location of GIT repository at SourceForge has changed.	2012-12-18 21:53:17 -06:00
Glenn Randers-Pehrson	350cbf14df	[libpng16] Fixed typo in contrib/pngminim/encoder/README	2012-12-18 14:54:44 -06:00
Glenn Randers-Pehrson	7bde6e23bb	[libpng16] Disassembled the version number in scripts/options.awk (necessary for building on SunOs)	2012-12-18 08:44:26 -06:00
Glenn Randers-Pehrson	5d9dc4563f	[libpng16] Fixed whitespace in libpng.3 manpage.	2012-12-17 20:03:08 -06:00
Glenn Randers-Pehrson	aa41547a4d	[libpng16] Updated manual about functions deprecated in libpng-1.6.x	2012-12-16 16:53:54 -06:00
Glenn Randers-Pehrson	8c3d4f387a	[libpng16] Bump version to 1.6.0beta34	2012-12-15 08:43:12 -06:00
Glenn Randers-Pehrson	6e265d137c	[libpng16] Note in CHANGES that configure files were rebuilt with autoconf-2.69	2012-12-15 08:29:41 -06:00
Glenn Randers-Pehrson	7b26920d9b	[libpng16] Imported from libpng-1.6.0beta33.tar	2012-12-15 07:58:38 -06:00
John Bowler	785a8b1505	[libpng16] Fixed cases of unquoted DESTDIR in Makefile.am	2012-12-15 07:57:31 -06:00
John Bowler	6cf32b460f	[libpng16] Rearranged the ARM-NEON optimizations: Isolated the machine specific code to the hardware subdirectory and added comments to pngrutil.c so that implementors of other optimizations know what to do.	2012-12-15 07:55:54 -06:00
John Bowler	f758d6c813	[libpng16] Rearranged the ARM-NEON optimizations: Isolated the machine specific code to the hardware subdirectory and added comments to pngrutil.c so that implementors of other optimizations know what to do.	2012-12-13 11:26:50 -06:00
Glenn Randers-Pehrson	5c2d76fdef	[libpng16] Use "FALL THROUGH" comment consistently in switch statements.	2012-12-09 19:39:30 -06:00
Glenn Randers-Pehrson	e4f124e335	[libpng16] Bump version to 1.6.0beta33	2012-12-09 19:25:42 -06:00
John Bowler	1f84bd7000	[libpng16] Change png_warning() to png_app_error() in pngwrite.c and comment the fall-through condition.	2012-12-09 18:50:49 -06:00
Glenn Randers-Pehrson	b76ab1260d	[libpng16] Fixed typo in png.c (PNG_SET_CHUNK_MALLOC_MAX should be PNG_CHUNK_MALLOC_MAX) that causes the MALLOC_MAX limit not to work (John Bowler)	2012-12-09 17:08:13 -06:00
Glenn Randers-Pehrson	026b295698	[libpng16] Removed an incorrect paragraph about png_benign_error from the manual page.	2012-11-27 14:49:22 -06:00
Glenn Randers-Pehrson	eb8e19baa3	[libpng16] Revised description of libpng15 to libpng16 changes in the manual.	2012-11-26 18:54:33 -06:00
Glenn Randers-Pehrson	661bc6f6b0	[libpng16] Expanded manual description of libpng15 to libpng16 changes.	2012-11-26 18:39:59 -06:00
Glenn Randers-Pehrson	6dae6d8f3b	[libpng16] Imported from libpng-1.6.0beta32.tar	2012-11-25 12:47:44 -06:00
Glenn Randers-Pehrson	5b9a28f2b8	[libpng16] Trivial editing of commentary in pngrutil.c	2012-11-25 12:46:24 -06:00
Glenn Randers-Pehrson	5f4b95e513	[libpng16] Made png_user_version_check() ok to use with libpng version 1.10.x and later.	2012-11-22 16:58:30 -06:00
John Bowler	70850fce0c	[libpng16] Fixed error checking in the simplified write API (Olaf van der Spek)	2012-11-15 00:06:30 -06:00
Glenn Randers-Pehrson	9d1ddbb78f	[libpng16] Fixed several typos and expanded TAB characters.	2012-11-13 19:45:53 -06:00
John Bowler	f2aacefb3f	[libpng16] Added the ability for contrib/libtests/makepng.c to make a PNG with just one color. This is useful for debugging pngstest color inaccuracy reports.	2012-11-13 19:18:53 -06:00
John Bowler	4314d63792	[libpng16] Fixed an intermittent SEGV in pngstest.	2012-11-02 14:08:29 -05:00
Glenn Randers-Pehrson	7b3eefbcfd	[libpng16] Bump version to 1.6.0beta32	2012-11-01 08:37:52 -05:00
Glenn Randers-Pehrson	bb39dc545c	[libpng16] Imported from libpng-1.6.0beta31.tar	2012-11-01 08:26:57 -05:00
John Bowler	520803d57e	[libpng16] Removed non-working ICC profile support code. There was too much code for too little gain; implementing full ICC color correction is maybe desireable but is left up to applications.	2012-11-01 08:12:47 -05:00
John Bowler	7f912dbeb5	[libpng16] Fixed GUIDs in projects/vstudio. Some were duplicated or missing, resulting in VS2010 having to update the files.	2012-10-27 13:04:56 -05:00
John Bowler	ab1477d662	[libpng16] Made PNG_NO_READ_GAMMA switch off interfaces that depend on READ_GAMMA. Prior to 1.6.0 switching off READ_GAMMA did unpredictable things to the interfaces that use it (specifically, png_do_background in 1.4 would simply display composite for grayscale images but do composition with the incorrect arithmetic for color ones). In 1.6 the semantic of -DPNG_NO_READ_GAMMA is changed to simply disable any interface that depends on it; this obliges people who set it to consider whether they really want it off if they happen to use any of the interfaces in question (typically most users who disable it won't).	2012-10-27 06:57:12 -05:00
John Bowler	f0fb1746b0	[libpng16] Make builds -DPNG_NO_READ_GAMMA compile (the unit tests still fail).	2012-10-26 08:29:45 -05:00
John Bowler	f8dfd123e2	[libpng16] Changed ICC profile support to allow use of an external color management system (CMS). In practice it is not possible to obtain cHRM information reliably using just the end-point tags because they do not exist in the vast majority of profiles. Instead it is necessary to run the endpoints through the ICC colorimetric intent transform (as described in the v4 spec). Since this is likely to be too much code inside libpng for too little gain (it implies a fairly complete CMS implementation) the code has been changed to allow an external CMS to be used. This code is temporarily disabled until a suitable set of test cases using one or more external CMS implementations have been implemented.	2012-10-25 19:30:02 -05:00
John Bowler	e6b710cb3f	[libpng16] Made pngvalid so that it will build outside the libpng source tree.	2012-10-25 19:15:55 -05:00
John Bowler	be85fa6027	[libpng16] Undid the erroneous change to vstudio/pngvalid build in libpng-1.6.0beta30.	2012-10-25 19:09:55 -05:00
Glenn Randers-Pehrson	43648b02bc	[libpng16] Bump version to 1.6.0beta31	2012-10-24 11:37:18 -05:00
Glenn Randers-Pehrson	75fde9e99a	[libpng16] Imported from libpng-1.6.0beta30.tar	2012-10-24 11:37:08 -05:00
Glenn Randers-Pehrson	9a82547afe	[libpng16] Fixed build when using #define PNG_NO_READ_GAMMA in png_do_compose() in pngrtran.c (Domani Hannes).	2012-10-24 11:22:35 -05:00
Glenn Randers-Pehrson	a9f44be8c2	[libpng16] Minor documentation edits	2012-10-10 15:02:00 -05:00
John Bowler	e15b1e8136	[libpng16] Added pngunknown files that were omitted from previous checkin	2012-09-30 14:10:43 -05:00
John Bowler	fa63beaa34	[libpng16] Use /MDd for vstudio debug builds. Also added pngunkown to the vstudio builds, fixed build errors and corrected a minor exit code error in pngvalid if the 'touch' file name is invalid.	2012-09-30 06:53:50 -05:00
John Bowler	c39be26f5a	[libpng16] Add updated WARNING file from libpng 1.5/vstudio	2012-09-29 17:48:53 -05:00
Glenn Randers-Pehrson	6ae34790cc	[libpng16] Added -DZ_SOLO to contrib/pngminim/*/makefile so they will work with zlib-1.2.7	2012-09-27 18:52:30 -05:00
John Bowler	8de49d0921	[libpng16] Marked the broken (bad white point) original HP sRGB profiles correctly and correct comments.	2012-09-27 09:26:49 -05:00
John Bowler	48cbba8e8e	[libpng16] Added a work around for GCC 4.2 optimization bug	2012-09-06 15:47:49 -05:00
John Bowler	b257147015	[libpng16] Changed ICC profile matrix/vector types to not depend on array type rules. By the ANSI-C standard the new types should be identical to the previous versions, and all known versions of gcc tested with the previous versions except for GCC-4.2.1 work with this version. The change makes the ANSI-C rule that const applied to an array of elements applies instead to the elements in the array moot by explicitly applying const to the base elements of the png_icc_matrix and png_icc_vector types. The accidental (harmless) 'const' previously applied to the parameters of two of the functions have also been removed.	2012-09-06 12:17:00 -05:00
Glenn Randers-Pehrson	73f826cb49	[libpng16] Fixed spelling of "chromaticAdaptationTag" in error messages.	2012-09-05 09:14:37 -05:00
Glenn Randers-Pehrson	933bc842ac	[libpng16] Fix confusion between "adopted" and "adapted" in new comments. Glenn thought the "adopted" were typos and changed them all to "adapted". This reverts the spelling and adds parenthetical comments when each word first appears in png.h.	2012-09-04 20:16:25 -05:00
Glenn Randers-Pehrson	329d033d25	[libpng16] Bump version to 1.6.0beta30	2012-09-04 16:59:30 -05:00