aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorGreg Lewis <glewis@FreeBSD.org>2015-05-06 07:03:53 +0000
committerGreg Lewis <glewis@FreeBSD.org>2015-05-06 07:03:53 +0000
commit6e15254a686a521b7c5e03e8b4855b7b00073130 (patch)
treec55895c151f879852bf010826f4dbea42a8767fe
parentb9e4c2bdc64d5f3f7dceca4b8e9881e5c3743ba2 (diff)
downloadports-6e15254a686a521b7c5e03e8b4855b7b00073130.tar.gz
ports-6e15254a686a521b7c5e03e8b4855b7b00073130.zip
Notes
Diffstat
-rw-r--r--java/openjdk8/Makefile10
-rw-r--r--java/openjdk8/files/patch-8u45-b1445638
-rw-r--r--java/openjdk8/files/patch-bsd618
-rw-r--r--java/openjdk8/files/patch-bsd-test468
-rw-r--r--java/openjdk8/files/patch-jdk-make-lib-Awt2dLibraries.gmk2
5 files changed, 46187 insertions, 549 deletions
diff --git a/java/openjdk8/Makefile b/java/openjdk8/Makefile
index 65bbd36aeab1..3b0f337f23ed 100644
--- a/java/openjdk8/Makefile
+++ b/java/openjdk8/Makefile
@@ -2,7 +2,6 @@
PORTNAME= openjdk
PORTVERSION= ${JDK_MAJOR_VERSION}.${JDK_UPDATE_VERSION}.${JDK_BUILD_NUMBER:S/^0//}
-PORTREVISION= 3
CATEGORIES= java devel
MASTER_SITES= http://download.java.net/openjdk/jdk${JDK_MAJOR_VERSION}/promoted/b${DIST_BUILD_NUMBER}/:jdk \
https://adopt-openjdk.ci.cloudbees.com/job/jtreg/${JTREG_JENKINS_BUILD}/artifact/:jtreg \
@@ -26,9 +25,10 @@ LIB_DEPENDS= libasound.so:${PORTSDIR}/audio/alsa-lib \
RUN_DEPENDS= javavm:${PORTSDIR}/java/javavmwrapper \
dejavu>0:${PORTSDIR}/x11-fonts/dejavu
-USES= compiler:features dos2unix gmake iconv pkgconfig shebangfix
-USE_AUTOTOOLS= autoconf
+USES= compiler:features dos2unix gmake iconv pkgconfig \
+ shebangfix
USE_XORG= x11 xext xi xrender xt xtst
+GNU_CONFIGURE= yes
.if !exists(/usr/bin/unzip)
BUILD_DEPENDS+= ${UNZIP_CMD}:${PORTSDIR}/archivers/unzip
@@ -92,8 +92,8 @@ NO_CCACHE= yes
NOPRECIOUSMAKEVARS= yes
JDK_MAJOR_VERSION= 8
-JDK_UPDATE_VERSION= 40
-JDK_BUILD_NUMBER= 25
+JDK_UPDATE_VERSION= 45
+JDK_BUILD_NUMBER= 14
DIST_BUILD_NUMBER= 132
JTREG_VERSION= 4.1
JTREG_BUILD_NUMBER= b08
diff --git a/java/openjdk8/files/patch-8u45-b14 b/java/openjdk8/files/patch-8u45-b14
new file mode 100644
index 000000000000..19470282608c
--- /dev/null
+++ b/java/openjdk8/files/patch-8u45-b14
@@ -0,0 +1,45638 @@
+--- ./.hgtags Wed Jan 28 12:08:30 2015 -0800
++++ ./.hgtags Tue Mar 17 11:22:18 2015 -0700
+@@ -336,6 +336,8 @@
+ d117f01bfb4f34668ac216c9837e88acead14dce jdk8u25-b17
+ efac90a2da447c2b2d43ee1b1e20c0828659f9c5 jdk8u25-b18
+ 1a0b4ec68abc4e9248ca6041fff04612674a9b9f jdk8u25-b31
++cc8541804eb47d86b30c5b005c6fa6ecb6a53538 jdk8u25-b32
++ec5219b942d277059d89063fb3702bc5e076dfd0 jdk8u25-b33
+ 6db0898d3f90ad9eae2f017299314b88766446e3 jdk8u31-b00
+ 85792859f3bdd6a2c1bdfcf2828bb2730e06ac3c jdk8u31-b01
+ 4898a7460ae620ac5356cb224e1fdf3c29312533 jdk8u31-b02
+@@ -350,6 +352,8 @@
+ ec85d5d0e3c05b0b6d61f4fc3f41313448ed9b05 jdk8u31-b11
+ ca98e3e9727ffdcde2c9980668d0c7f344261938 jdk8u31-b12
+ fde671d8b2537b6be61f67e583164b5b8b33ac5b jdk8u31-b13
++a198f93b1e0be5edce7a351b1399cb5c4e64c8f4 jdk8u31-b31
++99c79d83152585991682bd86e21fdcfe6f6ab9b2 jdk8u31-b32
+ 0dccc4aca1859b1ff7dca9db214f7f38c4ddbbce jdk8u40-b00
+ f8736a40a35df0c8055c8a94b96e5381b381ad33 jdk8u40-b01
+ b6a148730f2b14193c308bc9c866c36ee6c08ed3 jdk8u40-b02
+@@ -374,3 +378,21 @@
+ 765a17e75fd622f7b892381e23c9b2c531d416f0 jdk8u40-b21
+ b6d03a810a61116268fea08517a9632bd66a7363 jdk8u40-b22
+ 5dd2ad6c7911a1e21f15a28f13ffad662378a3be jdk8u40-b23
++5b37e6757d7c95c9c58b07fb3c9eba234567385a jdk8u40-b24
++e26f15704e37f28acebb22378c4785891aaec637 jdk8u40-b25
++7a552439756eaad0618ae82a94c034edb65f5d7e jdk8u40-b26
++12deacac825756e266e91a906db9edab73c4c90b jdk8u40-b27
++ec4bcc6e4dcf190a165106627ed3eef1e7d94d0c jdk8u45-b00
++635ba0c81b894a88ff737fefc9d7af398f761643 jdk8u45-b01
++801c65bb74b770600a2d48189764e416e5cfe265 jdk8u45-b02
++7d11a7eee8c0512fa15d3ed2dcded5391b0c091d jdk8u45-b03
++3d79ef8a102ffe22b083d07649a1d9e22cf784b6 jdk8u45-b04
++45f8fc9d30021026a5101c8946af98f7c079b537 jdk8u45-b05
++9a5843fdd2cf8120515d98572440c5c35118254d jdk8u45-b06
++74ef61db0fe02e3eaa5156a7bab9f00f2a2143de jdk8u45-b07
++0c10bc33556383b8e665998c62145a8398e7f7ef jdk8u45-b08
++733d16eb42cb105749588c9b93cc408155ed99ad jdk8u45-b09
++9a343fd13810a8f09d3dd4a9e2e20791bb866166 jdk8u45-b10
++6738b8755c80905e3eecedf94e27f03d23f02ba9 jdk8u45-b11
++54709b761404dd3bc1b58acf5582fa9bd70ff59a jdk8u45-b12
++6b2f1bf5c72873d01b37103fc20ac7a63e7881dd jdk8u45-b13
+--- ./THIRD_PARTY_README Wed Jan 28 12:08:30 2015 -0800
++++ ./THIRD_PARTY_README Tue Mar 17 11:22:18 2015 -0700
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
+--- ./corba/.hgtags Wed Jan 28 12:08:31 2015 -0800
++++ ./corba/.hgtags Tue Mar 17 11:22:27 2015 -0700
+@@ -334,6 +334,8 @@
+ f46df0af2ca8c7d896de375c8edac8ce09318318 jdk8u25-b17
+ ee069d67c12df902cdb06ecf1747f8ff9d495a61 jdk8u25-b18
+ 8d0faa0eac61c04c6a5bbff2e084c9da0bd5251c jdk8u25-b31
++6617e1de7aa536d2e3671e3c50c340262b2b053e jdk8u25-b32
++c123ac2adfdc6049034d5970bec89b51ce5d8889 jdk8u25-b33
+ 69793b08060c9d216fa84d679c48b9e22d2400ac jdk8u31-b00
+ fd5f8e3713803ca2d7898407a53996f3aa41521e jdk8u31-b01
+ b6e2d1b1b24585bd02512e360d842d4713afa644 jdk8u31-b02
+@@ -348,6 +350,8 @@
+ 7e2056eba0b62247407e065f3f88a89358fc26a6 jdk8u31-b11
+ 285b0e589c50e46ca7ad3434221335901a547d66 jdk8u31-b12
+ f89b454638d89ee5f44422b7a5b8e5651260e68f jdk8u31-b13
++705d3a4298f44f0a14925bfee5017f5824b6c0ca jdk8u31-b31
++072d325a052a5894019b74118803bf5fb9e30692 jdk8u31-b32
+ 7d1e0f0b63f1d66c77924d8b2a1accdf8f7480db jdk8u40-b00
+ c5d9822a3c18cd9e274dfe99e91c33e02bd8f8f4 jdk8u40-b01
+ 504b4455570e14b7fc0a837a09c6401c603516d9 jdk8u40-b02
+@@ -372,3 +376,21 @@
+ 9c54cc92c0beb29179abbce272d3f5c8ba4ffd0e jdk8u40-b21
+ 4c7421f74674ebefb8e91eba59ab2a2db8c1abd7 jdk8u40-b22
+ 62f7faef5ed956cd481cae6216b22fdb4b6e3e46 jdk8u40-b23
++472aa5bae0e78614e873d56bcc31e7caba49963c jdk8u40-b24
++2220744100b8487976debff79e5d0c7d70738bda jdk8u40-b25
++cab2b99c6bb2e15165a58eaa36157788f82592f1 jdk8u40-b26
++bd0186cd2419129357b110fe3f13519f68b29774 jdk8u40-b27
++5761efbc739fdedcbff224e22f920e88b29af4cf jdk8u45-b00
++6a52852476c9ccb2d52153d1b94b675e863bb28c jdk8u45-b01
++3b9d342f9f584465ea5976e06357b45682f9681d jdk8u45-b02
++d3678799ed35f162928f387308d72f5401b37e84 jdk8u45-b03
++9dd8c8e1b0facfcf21657c91fc99bcb5319d1196 jdk8u45-b04
++b82ecb056ae3fd6ee06e765995c564b17a761221 jdk8u45-b05
++f538a9334f09535ef8fe13072f6a4a52e3187e1c jdk8u45-b06
++4dec7b828f1ee3adbf3c2b6430400db8b1abb5ad jdk8u45-b07
++16cb989c8b6220330a54fe78ae27b2f50fc5e794 jdk8u45-b08
++ace36a054b7faadb702d6f23e569efb77f0a7513 jdk8u45-b09
++b9ef43c59b425961526b04e92d7fa66014ec25eb jdk8u45-b10
++08c2ce4b6d59bc6b29e61fd8562b9e3d39b257a5 jdk8u45-b11
++c9bf2543c0c045ef31f0296bc355381e1a4bd4ac jdk8u45-b12
++326f02235e7a9a6da78428410320dcc980827d40 jdk8u45-b13
+--- ./corba/THIRD_PARTY_README Wed Jan 28 12:08:31 2015 -0800
++++ ./corba/THIRD_PARTY_README Tue Mar 17 11:22:27 2015 -0700
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
+--- ./hotspot/.hgtags Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/.hgtags Tue Mar 17 11:22:51 2015 -0700
+@@ -547,6 +547,8 @@
+ 28b50d07f6f8c5a567b6a25e95a423948114a004 jdk8u25-b17
+ 639abc668bfe995dba811dd35411b9ea8a9041cd jdk8u25-b18
+ c3528699fb33fe3eb1d117504184ae7ab2507aa1 jdk8u25-b31
++631f0c7b49c091c6865d79d248d6551a270ac22f jdk8u25-b32
++4e1f52384f9ffa803838acad545cd63de48a7b35 jdk8u25-b33
+ 5bb683bbe2c74876d585b5c3232fc3aab7b23e97 jdk8u31-b00
+ 5bb686ae3b89f8aa1c74331b2d24e2a5ebd43448 jdk8u31-b01
+ 087678da96603c9705b38b6cc4a6569ac7b4420a jdk8u31-b02
+@@ -561,6 +563,8 @@
+ 9906d432d6dbd2cda242e3f3cfde7cf6c90245bf jdk8u31-b11
+ e13839545238d1ecf17f0489bb6fb765de46719a jdk8u31-b12
+ 4206e725d584be942c25ff46ff23d8e299ca4a4c jdk8u31-b13
++b517d3a9aebf0fee64808f9a7c0ef8e0b82d5ed3 jdk8u31-b31
++15d8108258cb60a58bdd03b9ff8e77dd6727a804 jdk8u31-b32
+ 1b3abbeee961dee49780c0e4af5337feb918c555 jdk8u40-b10
+ f10fe402dfb1543723b4b117a7cba3ea3d4159f1 hs25.40-b15
+ 99372b2fee0eb8b3452f47230e84aa6e97003184 jdk8u40-b11
+@@ -586,3 +590,21 @@
+ 0f0cb4eeab2d871274f4ffdcd6017d2fdfa89238 hs25.40-b25
+ 0ee548a1cda08c884eccd563e2d5fdb6ee769b5a jdk8u40-b22
+ 0e67683b700174eab71ea205d1cfa4f1cf4523ba jdk8u40-b23
++fa4e797f61e6dda1a60e06944018213bff2a1b76 jdk8u40-b24
++698dd28ecc785ffc43e3f12266b13e85382c26a8 jdk8u40-b25
++f39b6944ad447269b81e06ca5da9edff9e9e67c8 jdk8u40-b26
++6824e2475e0432e27f9cc51838bc34ea5fbf5113 jdk8u40-b27
++b95f13f05f553309cd74d6ccf8fcedb259c6716c jdk8u45-b00
++41c3c456e326185053f0654be838f4b0bfb38078 jdk8u45-b01
++626fd8c2eec63e2a2dff3839bfe12c0431bf00a4 jdk8u45-b02
++f41aa01b0a043611ee0abcb81a40f7d80085ec27 jdk8u45-b03
++2f586e3c4b6db807ac6036b485b2890ff82f7bfd jdk8u45-b04
++344ff6e45a1e2960ac4a583f63ebfb54cd52e6b4 jdk8u45-b05
++3afa9cc6e8d537ee456b8e12d1abb1da520b5ddc jdk8u45-b06
++5871f3dd9b4a2c4b44e7da2184f4430323e0c04b jdk8u45-b07
++35c7330b68e21d0dfaaedaaf74b794fd10606e9c jdk8u45-b08
++35d8318de0b6d4e68e2e0a04f6e20cafd113ca54 jdk8u45-b09
++a9f5786079202b74b3651e1097c0b2341b2178b9 jdk8u45-b10
++f4822d12204179e6a3e7aaf98991b6171670cbf2 jdk8u45-b11
++dc29108bcbcbfcd49eaa9135368306dc85db73a6 jdk8u45-b12
++efbf340fc7f56e49735111c23cef030413146409 jdk8u45-b13
+--- ./hotspot/THIRD_PARTY_README Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/THIRD_PARTY_README Tue Mar 17 11:22:51 2015 -0700
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
+--- ./hotspot/make/hotspot_version Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/make/hotspot_version Tue Mar 17 11:22:51 2015 -0700
+@@ -34,8 +34,8 @@
+ HOTSPOT_VM_COPYRIGHT=Copyright 2015
+
+ HS_MAJOR_VER=25
+-HS_MINOR_VER=40
+-HS_BUILD_NUMBER=25
++HS_MINOR_VER=45
++HS_BUILD_NUMBER=02
+
+ JDK_MAJOR_VER=1
+ JDK_MINOR_VER=8
+--- ./hotspot/src/cpu/sparc/vm/macroAssembler_sparc.inline.hpp Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/src/cpu/sparc/vm/macroAssembler_sparc.inline.hpp Tue Mar 17 11:22:51 2015 -0700
+@@ -630,7 +630,12 @@
+
+ inline void MacroAssembler::ldf(FloatRegisterImpl::Width w, const Address& a, FloatRegister d, int offset) {
+ relocate(a.rspec(offset));
+- ldf(w, a.base(), a.disp() + offset, d);
++ if (a.has_index()) {
++ assert(offset == 0, "");
++ ldf(w, a.base(), a.index(), d);
++ } else {
++ ldf(w, a.base(), a.disp() + offset, d);
++ }
+ }
+
+ // returns if membar generates anything, obviously this code should mirror
+--- ./hotspot/src/share/vm/classfile/defaultMethods.cpp Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/src/share/vm/classfile/defaultMethods.cpp Tue Mar 17 11:22:51 2015 -0700
+@@ -731,10 +731,12 @@
+ Method* m = iklass->find_method(_method_name, _method_signature);
+ // private interface methods are not candidates for default methods
+ // invokespecial to private interface methods doesn't use default method logic
++ // private class methods are not candidates for default methods,
++ // private methods do not override default methods, so need to perform
++ // default method inheritance without including private methods
+ // The overpasses are your supertypes' errors, we do not include them
+ // future: take access controls into account for superclass methods
+- if (m != NULL && !m->is_static() && !m->is_overpass() &&
+- (!iklass->is_interface() || m->is_public())) {
++ if (m != NULL && !m->is_static() && !m->is_overpass() && !m->is_private()) {
+ if (_family == NULL) {
+ _family = new StatefulMethodFamily();
+ }
+@@ -745,6 +747,9 @@
+ } else {
+ // This is the rule that methods in classes "win" (bad word) over
+ // methods in interfaces. This works because of single inheritance
++ // private methods in classes do not "win", they will be found
++ // first on searching, but overriding for invokevirtual needs
++ // to find default method candidates for the same signature
+ _family->set_target_if_empty(m);
+ }
+ }
+--- ./hotspot/src/share/vm/memory/referenceProcessor.cpp Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/src/share/vm/memory/referenceProcessor.cpp Tue Mar 17 11:22:51 2015 -0700
+@@ -252,7 +252,7 @@
+ // Cleaner references to be temporary, and don't want to deal with
+ // possible incompatibilities arising from making it more visible.
+ phantom_count +=
+- process_discovered_reflist(_discoveredCleanerRefs, NULL, false,
++ process_discovered_reflist(_discoveredCleanerRefs, NULL, true,
+ is_alive, keep_alive, complete_gc, task_executor);
+ }
+
+--- ./hotspot/src/share/vm/oops/klassVtable.cpp Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/src/share/vm/oops/klassVtable.cpp Tue Mar 17 11:22:51 2015 -0700
+@@ -401,13 +401,15 @@
+ // get super_klass for method_holder for the found method
+ InstanceKlass* super_klass = super_method->method_holder();
+
+- if (is_default
++ // private methods are also never overridden
++ if (!super_method->is_private() &&
++ (is_default
+ || ((super_klass->is_override(super_method, target_loader, target_classname, THREAD))
+ || ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
+ && ((super_klass = find_transitive_override(super_klass,
+ target_method, i, target_loader,
+ target_classname, THREAD))
+- != (InstanceKlass*)NULL))))
++ != (InstanceKlass*)NULL)))))
+ {
+ // Package private methods always need a new entry to root their own
+ // overriding. They may also override other methods.
+@@ -689,9 +691,15 @@
+ // check if a method is a miranda method, given a class's methods table,
+ // its default_method table and its super
+ // Miranda methods are calculated twice:
+-// first: before vtable size calculation: including abstract and default
++// first: before vtable size calculation: including abstract and superinterface default
++// We include potential default methods to give them space in the vtable.
++// During the first run, the default_methods list is empty
+ // This is seen by default method creation
+-// Second: recalculated during vtable initialization: only abstract
++// Second: recalculated during vtable initialization: only include abstract methods.
++// During the second run, default_methods is set up, so concrete methods from
++// superinterfaces with matching names/signatures to default_methods are already
++// in the default_methods list and do not need to be appended to the vtable
++// as mirandas
+ // This is seen by link resolution and selection.
+ // "miranda" means not static, not defined by this class.
+ // private methods in interfaces do not belong in the miranda list.
+@@ -706,8 +714,9 @@
+ }
+ Symbol* name = m->name();
+ Symbol* signature = m->signature();
++ Method* mo;
+
+- if (InstanceKlass::find_instance_method(class_methods, name, signature) == NULL) {
++ if ((mo = InstanceKlass::find_instance_method(class_methods, name, signature)) == NULL) {
+ // did not find it in the method table of the current class
+ if ((default_methods == NULL) ||
+ InstanceKlass::find_method(default_methods, name, signature) == NULL) {
+@@ -716,7 +725,7 @@
+ return true;
+ }
+
+- Method* mo = InstanceKlass::cast(super)->lookup_method(name, signature);
++ mo = InstanceKlass::cast(super)->lookup_method(name, signature);
+ while (mo != NULL && mo->access_flags().is_static()
+ && mo->method_holder() != NULL
+ && mo->method_holder()->super() != NULL)
+@@ -728,6 +737,18 @@
+ return true;
+ }
+ }
++ } else {
++ // if the local class has a private method, the miranda will not
++ // override it, so a vtable slot is needed
++ if (mo->access_flags().is_private()) {
++
++ // Second round, weed out any superinterface methods that turned
++ // into default methods, i.e. were concrete not abstract in the end
++ if ((default_methods == NULL) ||
++ InstanceKlass::find_method(default_methods, name, signature) == NULL) {
++ return true;
++ }
++ }
+ }
+
+ return false;
+--- ./hotspot/src/share/vm/runtime/arguments.cpp Fri Jan 30 15:14:31 2015 -0800
++++ ./hotspot/src/share/vm/runtime/arguments.cpp Tue Mar 17 11:22:51 2015 -0700
+@@ -2310,7 +2310,7 @@
+ "G1ConcMarkStepDurationMillis");
+ status = status && verify_interval(G1ConcRSHotCardLimit, 0, max_jubyte,
+ "G1ConcRSHotCardLimit");
+- status = status && verify_interval(G1ConcRSLogCacheSize, 0, 31,
++ status = status && verify_interval(G1ConcRSLogCacheSize, 0, 27,
+ "G1ConcRSLogCacheSize");
+ status = status && verify_interval(StringDeduplicationAgeThreshold, 1, markOopDesc::max_age,
+ "StringDeduplicationAgeThreshold");
+--- ./jaxp/.hgtags Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/.hgtags Tue Mar 17 11:23:49 2015 -0700
+@@ -336,6 +336,8 @@
+ 7a721e57b38ff6c1d34af0b86f6482540a815d90 jdk8u25-b17
+ fddbc00bde281d7d437b052262e921ed51de8b9a jdk8u25-b18
+ 30420a31a81f21e363f412ae9801b7467c8cc908 jdk8u25-b31
++b4231e682f98c8f7037e00fe6ef446d05a01811b jdk8u25-b32
++1c17ffddb76625e835d225c84a8c6ff23c1e5729 jdk8u25-b33
+ 19b6e16343925a4bf27879795b530d4f64e5d262 jdk8u31-b00
+ 469792d179304c9b3218930112547577e1aecb77 jdk8u31-b01
+ adbd3e31ef1a95b3f80a77dfbb843d52c053c6d3 jdk8u31-b02
+@@ -350,6 +352,8 @@
+ f475dbc70345904bda6b520af43955e244292886 jdk8u31-b11
+ 6563e438377f2086253577e08593b1ddfb901eff jdk8u31-b12
+ 1dd828fd98f1b84de5dcadb904322b711e7489ff jdk8u31-b13
++dcc563c9db9ef290a0783378d43a039cd92a08e3 jdk8u31-b31
++119f4ae3151f4134a5e62034e66a4c17f524838b jdk8u31-b32
+ 3a1bba8076da4e54882123e98e219eab1c31ccef jdk8u40-b00
+ f219da378d0768ff042d77221e5d20676ecc16f0 jdk8u40-b01
+ 16ef2134c32a4e60b5a60105b371163aa5936278 jdk8u40-b02
+@@ -374,3 +378,21 @@
+ 78d90db9de2801eec010ccb9f0db3caf969dfc3b jdk8u40-b21
+ 54a13451ce243f2159ed3996e6efcf374a5750ca jdk8u40-b22
+ e07fbae1efeac4e50514384caa7d226af7414114 jdk8u40-b23
++048cebd17f73f23ce2295e360f31c1b6788195aa jdk8u40-b24
++4c0d4c38279c5790aa5b61b03c4cfa9b2a58bc72 jdk8u40-b25
++f693ef62c207dd0290957c95bd62ab653afe4626 jdk8u40-b26
++56f6ca79467d04eb95383102046836b6ac7d2811 jdk8u40-b27
++9286acc600a779acb8bcfab38e82d4f50704afe3 jdk8u45-b00
++9fded65e1d36e3388111955d50ebf8511dd0345e jdk8u45-b01
++62566a3dbe5982565ce3e468ee3980b7937a86cc jdk8u45-b02
++629096783c27510c656229b1adc7fb180cada9c6 jdk8u45-b03
++85585012b976b72665f8f7740526bde25ccc62e4 jdk8u45-b04
++da025bade645f0d1e0ef2f825320bd5af0c23eba jdk8u45-b05
++49bc5472ded41c77dabb0840d385cbee1d60d8e9 jdk8u45-b06
++061930bd7d8fc2f05042e7eeb32adff1759c6d62 jdk8u45-b07
++50fba38f3a29f55baaae2da9b392bf9abc8389c1 jdk8u45-b08
++f893d8b9a0d148951014610b1aab2ba0a5105dfe jdk8u45-b09
++4de18a629048b90e0d875b9c0bd31800f1cc02ae jdk8u45-b10
++d4042340fe0aa9d33a161890e179bc21b6c7b8e6 jdk8u45-b11
++91d1102264e9b58b2ada4b5f112d472f0d86092b jdk8u45-b12
++a15025742f201f05ead3d731780a4ad437524491 jdk8u45-b13
+--- ./jaxp/THIRD_PARTY_README Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/THIRD_PARTY_README Tue Mar 17 11:23:49 2015 -0700
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/XalanConstants.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/XalanConstants.java Tue Mar 17 11:23:49 2015 -0700
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -151,6 +151,16 @@
+ */
+ public static final String SP_MAX_ELEMENT_DEPTH = "jdk.xml.maxElementDepth";
+
++ /**
++ * JDK TransformerFactory and Transformer attribute that specifies a class
++ * loader that will be used for extension functions class loading
++ * Value: a "null", the default value, means that the default EF class loading
++ * path will be used.
++ * Instance of ClassLoader: the specified instance of ClassLoader will be used
++ * for extension functions loading during translation process
++ */
++ public static final String JDK_EXTENSION_CLASSLOADER = "jdk.xml.transform.extensionClassLoader";
++
+ //legacy System Properties
+ public final static String ENTITY_EXPANSION_LIMIT = "entityExpansionLimit";
+ public static final String ELEMENT_ATTRIBUTE_LIMIT = "elementAttributeLimit" ;
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/FunctionCall.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/FunctionCall.java Tue Mar 17 11:23:49 2015 -0700
+@@ -104,6 +104,9 @@
+ protected final static String EXSLT_STRINGS =
+ "http://exslt.org/strings";
+
++ protected final static String XALAN_CLASSPACKAGE_NAMESPACE =
++ "xalan://";
++
+ // Namespace format constants
+ protected final static int NAMESPACE_FORMAT_JAVA = 0;
+ protected final static int NAMESPACE_FORMAT_CLASS = 1;
+@@ -900,8 +903,22 @@
+ if (_className != null && _className.length() > 0) {
+ final int nArgs = _arguments.size();
+ try {
+- if (_clazz == null) {
+- _clazz = ObjectFactory.findProviderClass(_className, true);
++ if (_clazz == null) {
++ final boolean isSecureProcessing = getXSLTC().isSecureProcessing();
++ final boolean isExtensionFunctionEnabled = getXSLTC()
++ .getFeature(FeatureManager.Feature.ORACLE_ENABLE_EXTENSION_FUNCTION);
++
++ //Check if FSP and SM - only then proceed with loading
++ if (namespace != null && isSecureProcessing
++ && isExtensionFunctionEnabled
++ && (namespace.equals(JAVA_EXT_XALAN)
++ || namespace.equals(JAVA_EXT_XSLTC)
++ || namespace.equals(JAVA_EXT_XALAN_OLD)
++ || namespace.startsWith(XALAN_CLASSPACKAGE_NAMESPACE))) {
++ _clazz = getXSLTC().loadExternalFunction(_className);
++ } else {
++ _clazz = ObjectFactory.findProviderClass(_className, true);
++ }
+
+ if (_clazz == null) {
+ final ErrorMsg msg =
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/XSLTC.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/XSLTC.java Tue Mar 17 11:23:49 2015 -0700
+@@ -23,24 +23,6 @@
+
+ package com.sun.org.apache.xalan.internal.xsltc.compiler;
+
+-import java.io.BufferedOutputStream;
+-import java.io.ByteArrayOutputStream;
+-import java.io.File;
+-import java.io.FileOutputStream;
+-import java.io.IOException;
+-import java.io.InputStream;
+-import java.net.URL;
+-import java.util.Date;
+-import java.util.Enumeration;
+-import java.util.Hashtable;
+-import java.util.Map;
+-import java.util.Properties;
+-import java.util.Vector;
+-import java.util.jar.JarEntry;
+-import java.util.jar.JarOutputStream;
+-import java.util.jar.Manifest;
+-import javax.xml.XMLConstants;
+-
+ import com.sun.org.apache.bcel.internal.classfile.JavaClass;
+ import com.sun.org.apache.xalan.internal.XalanConstants;
+ import com.sun.org.apache.xalan.internal.utils.FeatureManager;
+@@ -50,7 +32,27 @@
+ import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
+ import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;
+ import com.sun.org.apache.xml.internal.dtm.DTM;
+-
++import java.io.BufferedOutputStream;
++import java.io.ByteArrayOutputStream;
++import java.io.File;
++import java.io.FileOutputStream;
++import java.io.IOException;
++import java.io.InputStream;
++import java.net.URL;
++import java.security.AccessController;
++import java.security.PrivilegedAction;
++import java.util.Collections;
++import java.util.Date;
++import java.util.Enumeration;
++import java.util.HashMap;
++import java.util.Hashtable;
++import java.util.Map;
++import java.util.Properties;
++import java.util.Vector;
++import java.util.jar.JarEntry;
++import java.util.jar.JarOutputStream;
++import java.util.jar.Manifest;
++import javax.xml.XMLConstants;
+ import org.xml.sax.InputSource;
+ import org.xml.sax.XMLReader;
+
+@@ -153,11 +155,25 @@
+ private final FeatureManager _featureManager;
+
+ /**
++ * Extension function class loader variables
++ */
++
++ /* Class loader reference that will be used for external extension functions loading */
++ private ClassLoader _extensionClassLoader;
++
++ /**
++ * HashMap with the loaded classes
++ */
++ private final Map<String, Class> _externalExtensionFunctions;
++
++ /**
+ * XSLTC compiler constructor
+ */
+ public XSLTC(boolean useServicesMechanism, FeatureManager featureManager) {
+ _parser = new Parser(this, useServicesMechanism);
+ _featureManager = featureManager;
++ _extensionClassLoader = null;
++ _externalExtensionFunctions = new HashMap<>();
+ }
+
+ /**
+@@ -207,6 +223,8 @@
+ return _accessExternalDTD;
+ } else if (name.equals(XalanConstants.SECURITY_MANAGER)) {
+ return _xmlSecurityManager;
++ } else if (name.equals(XalanConstants.JDK_EXTENSION_CLASSLOADER)) {
++ return _extensionClassLoader;
+ }
+ return null;
+ }
+@@ -222,6 +240,11 @@
+ _accessExternalDTD = (String)value;
+ } else if (name.equals(XalanConstants.SECURITY_MANAGER)) {
+ _xmlSecurityManager = (XMLSecurityManager)value;
++ } else if (name.equals(XalanConstants.JDK_EXTENSION_CLASSLOADER)) {
++ _extensionClassLoader = (ClassLoader) value;
++ /* Clear the external extension functions HashMap if extension class
++ loader was changed */
++ _externalExtensionFunctions.clear();
+ }
+ }
+
+@@ -256,6 +279,41 @@
+ _bcelClasses = new Vector();
+ }
+
++ private void setExternalExtensionFunctions(String name, Class clazz) {
++ if (_isSecureProcessing && clazz != null && !_externalExtensionFunctions.containsKey(name)) {
++ _externalExtensionFunctions.put(name, clazz);
++ }
++ }
++
++ /*
++ * Function loads an external extension functions.
++ * The filtering of function types (external,internal) takes place in FunctionCall class
++ *
++ */
++ Class loadExternalFunction(String name) throws ClassNotFoundException {
++ Class loaded = null;
++ //Check if the function is not loaded already
++ if (_externalExtensionFunctions.containsKey(name)) {
++ loaded = _externalExtensionFunctions.get(name);
++ } else if (_extensionClassLoader != null) {
++ loaded = Class.forName(name, true, _extensionClassLoader);
++ setExternalExtensionFunctions(name, loaded);
++ }
++ if (loaded == null) {
++ throw new ClassNotFoundException(name);
++ }
++ //Return loaded class
++ return (Class) loaded;
++ }
++
++ /*
++ * Returns unmodifiable view of HashMap with loaded external extension
++ * functions - will be needed for the TransformerImpl
++ */
++ public Map<String, Class> getExternalExtensionFunctions() {
++ return Collections.unmodifiableMap(_externalExtensionFunctions);
++ }
++
+ /**
+ * Initializes the compiler to produce a new translet
+ */
+@@ -283,6 +341,7 @@
+ -1, // LEVEL_MULTIPLE
+ -1 // LEVEL_ANY
+ };
++ _externalExtensionFunctions.clear();
+ }
+
+ /**
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/util/ErrorMessages.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/util/ErrorMessages.java Tue Mar 17 11:23:49 2015 -0700
+@@ -599,6 +599,9 @@
+ {ErrorMsg.JAXP_INVALID_ATTR_ERR,
+ "TransformerFactory does not recognise attribute ''{0}''."},
+
++ {ErrorMsg.JAXP_INVALID_ATTR_VALUE_ERR,
++ "Incorrect value specified for ''{0}'' attribute."},
++
+ /*
+ * Note to translators: "setResult()" and "startDocument()" are Java
+ * method names that should not be translated.
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/util/ErrorMsg.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/compiler/util/ErrorMsg.java Tue Mar 17 11:23:49 2015 -0700
+@@ -117,6 +117,7 @@
+ public static final String JAXP_NO_SOURCE_ERR = "JAXP_NO_SOURCE_ERR";
+ public static final String JAXP_COMPILE_ERR = "JAXP_COMPILE_ERR";
+ public static final String JAXP_INVALID_ATTR_ERR = "JAXP_INVALID_ATTR_ERR";
++ public static final String JAXP_INVALID_ATTR_VALUE_ERR = "JAXP_INVALID_ATTR_VALUE_ERR";
+ public static final String JAXP_SET_RESULT_ERR = "JAXP_SET_RESULT_ERR";
+ public static final String JAXP_NO_TRANSLET_ERR = "JAXP_NO_TRANSLET_ERR";
+ public static final String JAXP_NO_HANDLER_ERR = "JAXP_NO_HANDLER_ERR";
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/runtime/BasisLibrary.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/runtime/BasisLibrary.java Tue Mar 17 11:23:49 2015 -0700
+@@ -270,8 +270,8 @@
+ if (Double.isNaN(start))
+ return(EMPTYSTRING);
+
+- final int strlen = value.length();
+- int istart = (int)Math.round(start) - 1;
++ final int strlen = value.length();
++ int istart = (int)Math.round(start) - 1;
+
+ if (istart > strlen)
+ return(EMPTYSTRING);
+@@ -292,10 +292,11 @@
+ public static String substringF(String value, double start, double length) {
+ if (Double.isInfinite(start) ||
+ Double.isNaN(start) ||
+- Double.isNaN(length))
++ Double.isNaN(length) ||
++ length < 0)
+ return(EMPTYSTRING);
+
+- int istart = (int)Math.round(start) - 1;
++ int istart = (int)Math.round(start) - 1;
+ final int isum;
+ if (Double.isInfinite(length))
+ isum = Integer.MAX_VALUE;
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/trax/TemplatesImpl.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/trax/TemplatesImpl.java Tue Mar 17 11:23:49 2015 -0700
+@@ -24,28 +24,27 @@
+ package com.sun.org.apache.xalan.internal.xsltc.trax;
+
+ import com.sun.org.apache.xalan.internal.XalanConstants;
++import com.sun.org.apache.xalan.internal.utils.ObjectFactory;
++import com.sun.org.apache.xalan.internal.utils.SecuritySupport;
++import com.sun.org.apache.xalan.internal.xsltc.DOM;
++import com.sun.org.apache.xalan.internal.xsltc.Translet;
++import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
++import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
++import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;
+ import java.io.IOException;
+ import java.io.ObjectInputStream;
+ import java.io.ObjectOutputStream;
+ import java.io.Serializable;
+-import java.util.Properties;
+ import java.security.AccessController;
+ import java.security.PrivilegedAction;
+-
++import java.util.Map;
++import java.util.Properties;
+ import javax.xml.XMLConstants;
+ import javax.xml.transform.Templates;
+ import javax.xml.transform.Transformer;
+ import javax.xml.transform.TransformerConfigurationException;
+ import javax.xml.transform.URIResolver;
+
+-import com.sun.org.apache.xalan.internal.xsltc.DOM;
+-import com.sun.org.apache.xalan.internal.xsltc.Translet;
+-import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
+-import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
+-import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;
+-import com.sun.org.apache.xalan.internal.utils.ObjectFactory;
+-import com.sun.org.apache.xalan.internal.utils.SecuritySupport;
+-
+ /**
+ * @author Morten Jorgensen
+ * @author G. Todd Millerj
+@@ -131,8 +130,30 @@
+ private String _accessExternalStylesheet = XalanConstants.EXTERNAL_ACCESS_DEFAULT;
+
+ static final class TransletClassLoader extends ClassLoader {
++
++ private final Map<String,Class> _loadedExternalExtensionFunctions;
++
+ TransletClassLoader(ClassLoader parent) {
+ super(parent);
++ _loadedExternalExtensionFunctions = null;
++ }
++
++ TransletClassLoader(ClassLoader parent,Map<String, Class> mapEF) {
++ super(parent);
++ _loadedExternalExtensionFunctions = mapEF;
++ }
++
++ public Class<?> loadClass(String name) throws ClassNotFoundException {
++ Class<?> ret = null;
++ // The _loadedExternalExtensionFunctions will be empty when the
++ // SecurityManager is not set and the FSP is turned off
++ if (_loadedExternalExtensionFunctions != null) {
++ ret = _loadedExternalExtensionFunctions.get(name);
++ }
++ if (ret == null) {
++ ret = super.loadClass(name);
++ }
++ return ret;
+ }
+
+ /**
+@@ -330,7 +351,7 @@
+ TransletClassLoader loader = (TransletClassLoader)
+ AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+- return new TransletClassLoader(ObjectFactory.findClassLoader());
++ return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
+ }
+ });
+
+--- ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/trax/TransformerFactoryImpl.java Wed Jan 28 12:08:37 2015 -0800
++++ ./jaxp/src/com/sun/org/apache/xalan/internal/xsltc/trax/TransformerFactoryImpl.java Tue Mar 17 11:23:49 2015 -0700
+@@ -27,12 +27,12 @@
+ import com.sun.org.apache.xalan.internal.utils.FactoryImpl;
+ import com.sun.org.apache.xalan.internal.utils.FeatureManager;
+ import com.sun.org.apache.xalan.internal.utils.FeaturePropertyBase;
++import com.sun.org.apache.xalan.internal.utils.FeaturePropertyBase.State;
+ import com.sun.org.apache.xalan.internal.utils.ObjectFactory;
+ import com.sun.org.apache.xalan.internal.utils.SecuritySupport;
+ import com.sun.org.apache.xalan.internal.utils.XMLSecurityManager;
+ import com.sun.org.apache.xalan.internal.utils.XMLSecurityPropertyManager;
+ import com.sun.org.apache.xalan.internal.utils.XMLSecurityPropertyManager.Property;
+-import com.sun.org.apache.xalan.internal.utils.FeaturePropertyBase.State;
+ import com.sun.org.apache.xalan.internal.xsltc.compiler.Constants;
+ import com.sun.org.apache.xalan.internal.xsltc.compiler.SourceLoader;
+ import com.sun.org.apache.xalan.internal.xsltc.compiler.XSLTC;
+@@ -50,6 +50,7 @@
+ import java.net.URL;
+ import java.util.Enumeration;
+ import java.util.Hashtable;
++import java.util.Map;
+ import java.util.Properties;
+ import java.util.Vector;
+ import java.util.zip.ZipEntry;
+@@ -57,7 +58,6 @@
+ import javax.xml.XMLConstants;
+ import javax.xml.parsers.SAXParser;
+ import javax.xml.parsers.SAXParserFactory;
+-
+ import javax.xml.transform.ErrorListener;
+ import javax.xml.transform.Source;
+ import javax.xml.transform.Templates;
+@@ -231,6 +231,13 @@
+
+ private final FeatureManager _featureManager;
+
++ private ClassLoader _extensionClassLoader = null;
++
++ // Unmodifiable view of external extension function from xslt compiler
++ // It will be populated by user-specified extension functions during the
++ // type checking
++ private Map<String, Class> _xsltcExtensionFunctions;
++
+ /**
+ * javax.xml.transform.sax.TransformerFactory implementation.
+ */
+@@ -261,6 +268,12 @@
+
+ //Parser's security manager
+ _xmlSecurityManager = new XMLSecurityManager(true);
++ //Unmodifiable hash map with loaded external extension functions
++ _xsltcExtensionFunctions = null;
++ }
++
++ public Map<String,Class> getExternalExtensionsMap() {
++ return _xsltcExtensionFunctions;
+ }
+
+ /**
+@@ -324,6 +337,8 @@
+ return Boolean.FALSE;
+ } else if (name.equals(XalanConstants.SECURITY_MANAGER)) {
+ return _xmlSecurityManager;
++ } else if (name.equals(XalanConstants.JDK_EXTENSION_CLASSLOADER)) {
++ return _extensionClassLoader;
+ }
+
+ /** Check to see if the property is managed by the security manager **/
+@@ -439,6 +454,16 @@
+ return;
+ }
+ }
++ else if ( name.equals(XalanConstants.JDK_EXTENSION_CLASSLOADER)) {
++ if (value instanceof ClassLoader) {
++ _extensionClassLoader = (ClassLoader) value;
++ return;
++ } else {
++ final ErrorMsg err
++ = new ErrorMsg(ErrorMsg.JAXP_INVALID_ATTR_VALUE_ERR, "Extension Functions ClassLoader");
++ throw new IllegalArgumentException(err.toString());
++ }
++ }
+
+ if (_xmlSecurityManager != null &&
+ _xmlSecurityManager.setLimit(name, XMLSecurityManager.State.APIPROPERTY, value)) {
+@@ -881,7 +906,6 @@
+ // Reset the per-session attributes to their default values
+ // after each newTemplates() call.
+ resetTransientAttributes();
+-
+ return new TemplatesImpl(bytecodes, transletClassName, null, _indentNumber, this);
+ }
+ }
+@@ -898,8 +922,10 @@
+ xsltc.setProperty(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, _accessExternalStylesheet);
+ xsltc.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, _accessExternalDTD);
+ xsltc.setProperty(XalanConstants.SECURITY_MANAGER, _xmlSecurityManager);
++ xsltc.setProperty(XalanConstants.JDK_EXTENSION_CLASSLOADER, _extensionClassLoader);
+ xsltc.init();
+-
++ if (!_isNotSecureProcessing)
++ _xsltcExtensionFunctions = xsltc.getExternalExtensionFunctions();
+ // Set a document loader (for xsl:include/import) if defined
+ if (_uriResolver != null) {
+ xsltc.setSourceLoader(this);
+--- ./jaxws/.hgtags Wed Jan 28 12:08:39 2015 -0800
++++ ./jaxws/.hgtags Tue Mar 17 11:23:59 2015 -0700
+@@ -334,6 +334,8 @@
+ d47a47f961ee423ce03623098f62d79254c6f328 jdk8u25-b17
+ cb0ad90bfe3c497c7236c5480447c4bde110934f jdk8u25-b18
+ a345282d661be80f2cdee3c43e12fbe01e7ff6d5 jdk8u25-b31
++90b0097a98f161c3e605dc26abf97bb9fc278f33 jdk8u25-b32
++da8457217afd472276c62f558fb1431f7e0e3bc0 jdk8u25-b33
+ 3a676fe898c93ad3afcaa55a71da96455e5f230e jdk8u31-b00
+ 1c73ca9179f22d4a73d1a248a3254f891c71ee30 jdk8u31-b01
+ c1f1ed28e0bb68d7536fb30bb6f1a3623816b12a jdk8u31-b02
+@@ -348,6 +350,8 @@
+ 497c783d228ed188d61964edd409794af3ad3e5c jdk8u31-b11
+ 959e8fca46155528c8147da69a7c49edfb002cb1 jdk8u31-b12
+ 9d0c737694ece23547c0a27dcd0ba6cbcdf577f2 jdk8u31-b13
++49e91817cbe1b14f856c26f6e55b7151e3f8c3a8 jdk8u31-b31
++9e20c5acb448c5f9b05a4e9b4efc222b3b616c23 jdk8u31-b32
+ 31d43d250c836c13fcc87025837783788c5cd0de jdk8u40-b00
+ 262fb5353ffa661f88b4a9cf2581fcad8c2a43f7 jdk8u40-b01
+ 8043f77ef8a4ded9505269a356c4e2f4f9604cd9 jdk8u40-b02
+@@ -372,3 +376,21 @@
+ 16485a38b6bc762b363f4e439047486742fbcfcb jdk8u40-b21
+ 6e928fd9152541eddf25694be89eb881434a5c5f jdk8u40-b22
+ b6755a463ccf6a79b1e1a43ed7bdb1c5cb1ac17d jdk8u40-b23
++5fbbfd66643edb81cfa0688825d698dcc5f2eb11 jdk8u40-b24
++b6120aaf2aeef7c5608d578e15e82db7eb24fb2e jdk8u40-b25
++1bcb30bdd9883cc7fc1bf70800ea03a4429eaa80 jdk8u40-b26
++a5f2cdedb940511674e153dce8d3cbc3a0598c9e jdk8u40-b27
++667a4aee3720373f5c286a50f537afd0ff4b65ae jdk8u45-b00
++cb6added4913f4899bd1689e77be1fe4efcff4f1 jdk8u45-b01
++855a7b9302053546e4da94b67cc3b8956f5b4985 jdk8u45-b02
++698a88182586b0914b204de27cc45d6f0dfe7683 jdk8u45-b03
++c7307f75843b64e6096205425ba2f7387017ee9e jdk8u45-b04
++6bd873f17e03cf285f576f69340123e3b2d8922f jdk8u45-b05
++a5e99f4d067ebea01e438e5b3e9b09bda47ddb25 jdk8u45-b06
++145ea6d2899f5cc6bd4e1108903e4d22ad063eca jdk8u45-b07
++f3d678fe58e7c026fb62be8b72c46ce1015aadf6 jdk8u45-b08
++8f2e5110151810dc5b56a3ce05d955e400bee937 jdk8u45-b09
++5cf887e3e1368d1910181eaab2794b25058fe8b6 jdk8u45-b10
++855fd9dfcbee177b508413dbab6e46b57dd367c4 jdk8u45-b11
++3f6c3f48179ac8bab98509be8708edcea32727b6 jdk8u45-b12
++15fb2359f5f86dbacc1bc120f663853b5292cd14 jdk8u45-b13
+--- ./jaxws/THIRD_PARTY_README Wed Jan 28 12:08:39 2015 -0800
++++ ./jaxws/THIRD_PARTY_README Tue Mar 17 11:23:59 2015 -0700
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
+--- ./jaxws/src/share/jaxws_classes/com/sun/tools/internal/jxc/ap/SchemaGenerator.java Wed Jan 28 12:08:39 2015 -0800
++++ ./jaxws/src/share/jaxws_classes/com/sun/tools/internal/jxc/ap/SchemaGenerator.java Tue Mar 17 11:23:59 2015 -0700
+@@ -135,7 +135,7 @@
+
+ private void filterClass(List<Reference> classes, Collection<? extends Element> elements) {
+ for (Element element : elements) {
+- if (element.getKind().equals(ElementKind.CLASS)) {
++ if (element.getKind().equals(ElementKind.CLASS) || element.getKind().equals(ElementKind.ENUM)) {
+ classes.add(new Reference((TypeElement) element, processingEnv));
+ filterClass(classes, ElementFilter.typesIn(element.getEnclosedElements()));
+ }
+--- ./jdk/.hgtags Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/.hgtags Thu Feb 05 13:00:26 2015 +0100
+@@ -337,6 +337,8 @@
+ 67b22a82345bfa1ae1492679bdf3c4d54f4eacde jdk8u25-b17
+ a4e88eaf15ea0569f3275a807a976fe0e04a086c jdk8u25-b18
+ 556c79ef8a1d2fa38f79b3d3e102e80e0b0c9731 jdk8u25-b31
++5c06b8274d27aa45870f9555dcc60b7602236fa5 jdk8u25-b32
++afefb260f8f095bc02e758b58a4c354f2ea7bc69 jdk8u25-b33
+ f935349e2c065487c745bc41f81ddc7869bd2d2d jdk8u31-b00
+ caebf6158e9d522df41a2c89a1602e5013bac401 jdk8u31-b01
+ b1cef4d76664564732004cf3aedb0cbaa1972683 jdk8u31-b02
+@@ -351,6 +353,9 @@
+ a21dd7999d1e4ba612c951c2c78504d23eb7243a jdk8u31-b11
+ 6a12f34816d2ee12368274fc21225384a8893426 jdk8u31-b12
+ 1fbdd5d80d0671decd8acb5adb64866f609e986f jdk8u31-b13
++ced84cf3eebc69f7e04b0098d85dcb3a6b872586 jdk8u31-b31
++367c7f061c5831ee54cd197f727e06109a67875b jdk8u31-b14
++287e3219f3f531b2f20b50b180802a563a782b26 jdk8u31-b15
+ e6ed015afbbf3459ba3297e270b4f3170e989c80 jdk8u40-b00
+ 6e223d48080ef40f4ec11ecbcd19b4a20813b9eb jdk8u40-b01
+ 4797cd0713b44b009525f1276d571ade7e24f3f5 jdk8u40-b02
+@@ -375,3 +380,21 @@
+ 564bca490631e4ed4f7993e6633ed9ee62067624 jdk8u40-b21
+ d168113f9841a77b3cee3a6a45fcd85b7351ac90 jdk8u40-b22
+ 41fe61722ce96b75dd3a1ba5072473122e21e5a0 jdk8u40-b23
++9d903721276c8684706db7ecfb6cda568e9f4f69 jdk8u40-b24
++f0d5cb59b0e6a67fa102465458cc4725c6e59089 jdk8u40-b25
++97f258823d7d8ee0ec7d774b79cd30492520cc10 jdk8u40-b26
++d4453d784fb6c52e4ed998b167588551e2fd43c5 jdk8u40-b27
++1ecc234bd38950a2bc047aa253a5e803f0836a4e jdk8u45-b00
++e0c7864bbca3f76cde680722f2ae58dff2bff61d jdk8u45-b01
++9505c0392cddbfb905401e9fccc23262edc3254f jdk8u45-b02
++17af4523dfc7a0b978c9ca3d05212f07828e31d0 jdk8u45-b03
++a26b2f5bc72904eb269176d13afaf39b57a80b29 jdk8u45-b04
++4d95b1faad78b1e377eacceaa4ff81a3d7bbf549 jdk8u45-b05
++85ffe9aa18ac7c7fc474af03c61e4e96bb045796 jdk8u45-b06
++cdf1a9436aec569615913b96734df7a0e77c20e5 jdk8u45-b07
++6656dca5d05913fa204c79754624cd8fe77d7b49 jdk8u45-b08
++1083da8a8ec17058de5a35be3e5a821affc19e4e jdk8u45-b09
++3edfbb32b3c04941eedc551c02d4eec1e0f92078 jdk8u45-b10
++c669323bd55ac59ad26c7ee4f47a6daefc82af8e jdk8u45-b11
++6a8f9512afa687632f0a0d881bbdb446d984a74c jdk8u45-b12
++55a75b0db87693e1e186752f553c337cb035a38e jdk8u45-b13
+--- ./jdk/THIRD_PARTY_README Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/THIRD_PARTY_README Thu Feb 05 13:00:26 2015 +0100
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
+--- ./jdk/make/data/swingbeaninfo/SwingBeanInfo.template Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/swingbeaninfo/SwingBeanInfo.template Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1998, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -92,25 +92,38 @@
+ /**
+ * @return an icon of the specified kind for @(BeanClassName)
+ */
+- public Image getIcon(int kind) {
++ public Image getIcon(final int kind) {
+ Image i;
+ switch (kind){
+ case ICON_COLOR_32x32:
+- i = loadImage("beaninfo/images/@(BeanClassName)Color32.gif");
+- return ((i == null) ? loadImage("beaninfo/images/JComponentColor32.gif") : i);
++ i = loadStandardImage("beaninfo/images/@(BeanClassName)Color32.gif");
++ return ((i == null) ? loadStandardImage("beaninfo/images/JComponentColor32.gif") : i);
+ case ICON_COLOR_16x16:
+- i = loadImage("beaninfo/images/@(BeanClassName)Color16.gif");
+- return ((i == null) ? loadImage("beaninfo/images/JComponentColor16.gif") : i);
++ i = loadStandardImage("beaninfo/images/@(BeanClassName)Color16.gif");
++ return ((i == null) ? loadStandardImage("beaninfo/images/JComponentColor16.gif") : i);
+ case ICON_MONO_32x32:
+- i = loadImage("beaninfo/images/@(BeanClassName)Mono32.gif");
+- return ((i == null) ? loadImage("beaninfo/images/JComponentMono32.gif") : i);
++ i = loadStandardImage("beaninfo/images/@(BeanClassName)Mono32.gif");
++ return ((i == null) ? loadStandardImage("beaninfo/images/JComponentMono32.gif") : i);
+ case ICON_MONO_16x16:
+- i = loadImage("beaninfo/images/@(BeanClassName)Mono16.gif");
+- return ((i == null) ? loadImage("beaninfo/images/JComponentMono16.gif") : i);
++ i = loadStandardImage("beaninfo/images/@(BeanClassName)Mono16.gif");
++ return ((i == null) ? loadStandardImage("beaninfo/images/JComponentMono16.gif") : i);
+ default:
+ return super.getIcon(kind);
+ }
+ }
++
++ /**
++ * This is a utility method to help in loading standard icon images.
++ *
++ * @param resourceName A pathname relative to the directory holding the
++ * class file of the current class
++ * @return an image object. May be null if the load failed.
++ * @see java.beans.SimpleBeanInfo#loadImage(String)
++ */
++ private Image loadStandardImage(final String resourceName) {
++ return java.security.AccessController.doPrivileged(
++ (java.security.PrivilegedAction<Image>) () -> loadImage(resourceName));
++ }
+ }
+
+
+--- ./jdk/make/data/tzdata/VERSION Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/VERSION Thu Feb 05 13:00:26 2015 +0100
+@@ -21,4 +21,4 @@
+ # or visit www.oracle.com if you need additional information or have any
+ # questions.
+ #
+-tzdata2014j
++tzdata2015a
+--- ./jdk/make/data/tzdata/antarctica Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/antarctica Thu Feb 05 13:00:26 2015 +0100
+@@ -70,8 +70,8 @@
+ Rule ChileAQ 2010 only - Apr Sun>=1 3:00u 0 -
+ Rule ChileAQ 2011 only - May Sun>=2 3:00u 0 -
+ Rule ChileAQ 2011 only - Aug Sun>=16 4:00u 1:00 S
+-Rule ChileAQ 2012 max - Apr Sun>=23 3:00u 0 -
+-Rule ChileAQ 2012 max - Sep Sun>=2 4:00u 1:00 S
++Rule ChileAQ 2012 2015 - Apr Sun>=23 3:00u 0 -
++Rule ChileAQ 2012 2014 - Sep Sun>=2 4:00u 1:00 S
+
+ # Argentina - year-round bases
+ # Belgrano II, Confin Coast, -770227-0343737, since 1972-02-05
+@@ -377,9 +377,10 @@
+ #
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+ Zone Antarctica/Palmer 0 - zzz 1965
+- -4:00 ArgAQ AR%sT 1969 Oct 5
++ -4:00 ArgAQ AR%sT 1969 Oct 5
+ -3:00 ArgAQ AR%sT 1982 May
+- -4:00 ChileAQ CL%sT
++ -4:00 ChileAQ CL%sT 2015 Apr 26 3:00u
++ -3:00 - CLT
+ #
+ #
+ # McMurdo Station, Ross Island, since 1955-12
+--- ./jdk/make/data/tzdata/asia Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/asia Thu Feb 05 13:00:26 2015 +0100
+@@ -168,10 +168,7 @@
+ 4:00 Azer AZ%sT
+
+ # Bahrain
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Bahrain 3:22:20 - LMT 1920 # Manamah
+- 4:00 - GST 1972 Jun
+- 3:00 - AST
++# See Asia/Qatar.
+
+ # Bangladesh
+ # From Alexander Krivenyshev (2009-05-13):
+@@ -1754,9 +1751,7 @@
+ ###############################################################################
+
+ # Kuwait
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Kuwait 3:11:56 - LMT 1950
+- 3:00 - AST
++# See Asia/Riyadh.
+
+ # Laos
+ # See Asia/Bangkok.
+@@ -1977,12 +1972,7 @@
+ 5:45 - NPT # Nepal Time
+
+ # Oman
+-
+-# Milne says 3:54:24 was the meridian of the Muscat Tidal Observatory.
+-
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Muscat 3:54:24 - LMT 1920
+- 4:00 - GST
++# See Asia/Dubai.
+
+ # Pakistan
+
+@@ -2476,6 +2466,7 @@
+ Zone Asia/Qatar 3:26:08 - LMT 1920 # Al Dawhah / Doha
+ 4:00 - GST 1972 Jun
+ 3:00 - AST
++Link Asia/Qatar Asia/Bahrain
+
+ # Saudi Arabia
+ #
+@@ -2502,6 +2493,8 @@
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+ Zone Asia/Riyadh 3:06:52 - LMT 1947 Mar 14
+ 3:00 - AST
++Link Asia/Riyadh Asia/Aden # Yemen
++Link Asia/Riyadh Asia/Kuwait
+
+ # Singapore
+ # taken from Mok Ly Yng (2003-10-30)
+@@ -2790,6 +2783,7 @@
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+ Zone Asia/Dubai 3:41:12 - LMT 1920
+ 4:00 - GST
++Link Asia/Dubai Asia/Muscat # Oman
+
+ # Uzbekistan
+ # Byalokoz 1919 says Uzbekistan was 4:27:53.
+@@ -2874,10 +2868,4 @@
+ 7:00 - ICT
+
+ # Yemen
+-
+-# Milne says 2:59:54 was the meridian of the saluting battery at Aden,
+-# and that Yemen was at 1:55:56, the meridian of the Hagia Sophia.
+-
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Aden 2:59:54 - LMT 1950
+- 3:00 - AST
++# See Asia/Riyadh.
+--- ./jdk/make/data/tzdata/backward Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/backward Thu Feb 05 13:00:26 2015 +0100
+@@ -28,7 +28,7 @@
+ # and their old names. Many names changed in late 1993.
+
+ # Link TARGET LINK-NAME
+-Link Africa/Asmara Africa/Asmera
++Link Africa/Nairobi Africa/Asmera
+ Link Africa/Abidjan Africa/Timbuktu
+ Link America/Argentina/Catamarca America/Argentina/ComodRivadavia
+ Link America/Adak America/Atka
+--- ./jdk/make/data/tzdata/europe Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/europe Thu Feb 05 13:00:26 2015 +0100
+@@ -1430,35 +1430,32 @@
+ # might be a reference to the Julian calendar as opposed to Gregorian, or it
+ # might mean something else (???).
+ #
+-# From Paul Eggert (2006-03-22):
+-# The Iceland Almanak, Shanks & Pottenger, and Whitman disagree on many points.
+-# We go with the Almanak, except for one claim from Shanks & Pottenger, namely
+-# that Reykavik was 21W57 from 1837 to 1908, local mean time before that.
++# From Paul Eggert (2014-11-22):
++# The information below is taken from the 1988 Almanak; see
++# http://www.almanak.hi.is/klukkan.html
+ #
+ # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S
+-Rule Iceland 1917 1918 - Feb 19 23:00 1:00 S
++Rule Iceland 1917 1919 - Feb 19 23:00 1:00 S
+ Rule Iceland 1917 only - Oct 21 1:00 0 -
+-Rule Iceland 1918 only - Nov 16 1:00 0 -
++Rule Iceland 1918 1919 - Nov 16 1:00 0 -
++Rule Iceland 1921 only - Mar 19 23:00 1:00 S
++Rule Iceland 1921 only - Jun 23 1:00 0 -
+ Rule Iceland 1939 only - Apr 29 23:00 1:00 S
+-Rule Iceland 1939 only - Nov 29 2:00 0 -
++Rule Iceland 1939 only - Oct 29 2:00 0 -
+ Rule Iceland 1940 only - Feb 25 2:00 1:00 S
+-Rule Iceland 1940 only - Nov 3 2:00 0 -
+-Rule Iceland 1941 only - Mar 2 1:00s 1:00 S
+-Rule Iceland 1941 only - Nov 2 1:00s 0 -
+-Rule Iceland 1942 only - Mar 8 1:00s 1:00 S
+-Rule Iceland 1942 only - Oct 25 1:00s 0 -
++Rule Iceland 1940 1941 - Nov Sun>=2 1:00s 0 -
++Rule Iceland 1941 1942 - Mar Sun>=2 1:00s 1:00 S
+ # 1943-1946 - first Sunday in March until first Sunday in winter
+ Rule Iceland 1943 1946 - Mar Sun>=1 1:00s 1:00 S
+-Rule Iceland 1943 1948 - Oct Sun>=22 1:00s 0 -
++Rule Iceland 1942 1948 - Oct Sun>=22 1:00s 0 -
+ # 1947-1967 - first Sunday in April until first Sunday in winter
+ Rule Iceland 1947 1967 - Apr Sun>=1 1:00s 1:00 S
+-# 1949 Oct transition delayed by 1 week
++# 1949 and 1967 Oct transitions delayed by 1 week
+ Rule Iceland 1949 only - Oct 30 1:00s 0 -
+ Rule Iceland 1950 1966 - Oct Sun>=22 1:00s 0 -
+ Rule Iceland 1967 only - Oct 29 1:00s 0 -
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Atlantic/Reykjavik -1:27:24 - LMT 1837
+- -1:27:48 - RMT 1908 # Reykjavik Mean Time?
++Zone Atlantic/Reykjavik -1:28 - LMT 1908
+ -1:00 Iceland IS%sT 1968 Apr 7 1:00s
+ 0:00 - GMT
+
+--- ./jdk/make/data/tzdata/leapseconds Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/leapseconds Thu Feb 05 13:00:26 2015 +0100
+@@ -77,3 +77,7 @@
+ Leap 2005 Dec 31 23:59:60 + S
+ Leap 2008 Dec 31 23:59:60 + S
+ Leap 2012 Jun 30 23:59:60 + S
++Leap 2015 Jun 30 23:59:60 + S
++
++# Updated through IERS Bulletin C49
++# File expires on: 28 December 2015
+--- ./jdk/make/data/tzdata/northamerica Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/northamerica Thu Feb 05 13:00:26 2015 +0100
+@@ -147,7 +147,7 @@
+ Rule US 1918 1919 - Oct lastSun 2:00 0 S
+ Rule US 1942 only - Feb 9 2:00 1:00 W # War
+ Rule US 1945 only - Aug 14 23:00u 1:00 P # Peace
+-Rule US 1945 only - Sep 30 2:00 0 S
++Rule US 1945 only - Sep lastSun 2:00 0 S
+ Rule US 1967 2006 - Oct lastSun 2:00 0 S
+ Rule US 1967 1973 - Apr lastSun 2:00 1:00 D
+ Rule US 1974 only - Jan 6 2:00 1:00 D
+@@ -2147,11 +2147,11 @@
+
+ # Mexico
+
+-# From Paul Eggert (2001-03-05):
++# From Paul Eggert (2014-12-07):
+ # The Investigation and Analysis Service of the
+ # Mexican Library of Congress (MLoC) has published a
+ # history of Mexican local time (in Spanish)
+-# http://www.cddhcu.gob.mx/bibliot/publica/inveyana/polisoc/horver/
++# http://www.diputados.gob.mx/bibliot/publica/inveyana/polisoc/horver/index.htm
+ #
+ # Here are the discrepancies between Shanks & Pottenger (S&P) and the MLoC.
+ # (In all cases we go with the MLoC.)
+@@ -2320,6 +2320,24 @@
+ # efecto desde las dos horas del segundo domingo de marzo y concluirá a
+ # las dos horas del primer domingo de noviembre.
+
++# From Steffen Thorsen (2014-12-08), translated by Gwillim Law:
++# The Mexican state of Quintana Roo will likely change to EST in 2015.
++#
++# http://www.unioncancun.mx/articulo/2014/12/04/medio-ambiente/congreso-aprueba-una-hora-mas-de-sol-en-qroo
++# "With this change, the time conflict that has existed between the municipios
++# of Quintana Roo and the municipio of Felipe Carrillo Puerto may come to an
++# end. The latter declared itself in rebellion 15 years ago when a time change
++# was initiated in Mexico, and since then it has refused to change its time
++# zone along with the rest of the country."
++#
++# From Steffen Thorsen (2015-01-14), translated by Gwillim Law:
++# http://sipse.com/novedades/confirman-aplicacion-de-nueva-zona-horaria-para-quintana-roo-132331.html
++# "...the new time zone will come into effect at two o'clock on the first Sunday
++# of February, when we will have to advance the clock one hour from its current
++# time..."
++#
++# Also, the new zone will not use DST.
++
+ # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S
+ Rule Mexico 1939 only - Feb 5 0:00 1:00 D
+ Rule Mexico 1939 only - Jun 25 0:00 0 S
+@@ -2340,7 +2358,8 @@
+ Zone America/Cancun -5:47:04 - LMT 1922 Jan 1 0:12:56
+ -6:00 - CST 1981 Dec 23
+ -5:00 Mexico E%sT 1998 Aug 2 2:00
+- -6:00 Mexico C%sT
++ -6:00 Mexico C%sT 2015 Feb 1 2:00
++ -5:00 - EST
+ # Campeche, Yucatán; represented by Mérida
+ Zone America/Merida -5:58:28 - LMT 1922 Jan 1 0:01:32
+ -6:00 - CST 1981 Dec 23
+--- ./jdk/make/data/tzdata/southamerica Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/southamerica Thu Feb 05 13:00:26 2015 +0100
+@@ -1229,6 +1229,11 @@
+ # DST Start: first Saturday of September 2014 (Sun 07 Sep 2014 04:00 UTC)
+ # http://www.diariooficial.interior.gob.cl//media/2014/02/19/do-20140219.pdf
+
++# From Juan Correa (2015-01-28):
++# ... today the Ministry of Energy announced that Chile will drop DST, will keep
++# "summer time" (UTC -3 / UTC -5) all year round....
++# http://www.minenergia.cl/ministerio/noticias/generales/ministerio-de-energia-anuncia.html
++
+ # NOTE: ChileAQ rules for Antarctic bases are stored separately in the
+ # 'antarctica' file.
+
+@@ -1270,8 +1275,8 @@
+ Rule Chile 2010 only - Apr Sun>=1 3:00u 0 -
+ Rule Chile 2011 only - May Sun>=2 3:00u 0 -
+ Rule Chile 2011 only - Aug Sun>=16 4:00u 1:00 S
+-Rule Chile 2012 max - Apr Sun>=23 3:00u 0 -
+-Rule Chile 2012 max - Sep Sun>=2 4:00u 1:00 S
++Rule Chile 2012 2015 - Apr Sun>=23 3:00u 0 -
++Rule Chile 2012 2014 - Sep Sun>=2 4:00u 1:00 S
+ # IATA SSIM anomalies: (1992-02) says 1992-03-14;
+ # (1996-09) says 1998-03-08. Ignore these.
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+@@ -1282,11 +1287,13 @@
+ -4:00 - CLT 1919 Jul 1 # Chile Time
+ -4:42:46 - SMT 1927 Sep 1 # Santiago Mean Time
+ -5:00 Chile CL%sT 1947 May 22 # Chile Time
+- -4:00 Chile CL%sT
++ -4:00 Chile CL%sT 2015 Apr 26 3:00u
++ -3:00 - CLT
+ Zone Pacific/Easter -7:17:44 - LMT 1890
+ -7:17:28 - EMT 1932 Sep # Easter Mean Time
+- -7:00 Chile EAS%sT 1982 Mar 13 21:00 # Easter Time
+- -6:00 Chile EAS%sT
++ -7:00 Chile EAS%sT 1982 Mar 13 3:00u # Easter Time
++ -6:00 Chile EAS%sT 2015 Apr 26 3:00u
++ -5:00 - EAST
+ #
+ # Salas y Gómez Island is uninhabited.
+ # Other Chilean locations, including Juan Fernández Is, Desventuradas Is,
+--- ./jdk/make/data/tzdata/zone.tab Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/make/data/tzdata/zone.tab Thu Feb 05 13:00:26 2015 +0100
+@@ -297,7 +297,7 @@
+ MV +0410+07330 Indian/Maldives
+ MW -1547+03500 Africa/Blantyre
+ MX +1924-09909 America/Mexico_City Central Time - most locations
+-MX +2105-08646 America/Cancun Central Time - Quintana Roo
++MX +2105-08646 America/Cancun Eastern Standard Time - Quintana Roo
+ MX +2058-08937 America/Merida Central Time - Campeche, Yucatan
+ MX +2540-10019 America/Monterrey Mexican Central Time - Coahuila, Durango, Nuevo Leon, Tamaulipas away from US border
+ MX +2550-09730 America/Matamoros US Central Time - Coahuila, Durango, Nuevo Leon, Tamaulipas near US border
+--- ./jdk/src/macosx/native/sun/awt/splashscreen/splashscreen_sys.m Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/macosx/native/sun/awt/splashscreen/splashscreen_sys.m Thu Feb 05 13:00:26 2015 +0100
+@@ -131,11 +131,7 @@
+ NSAutoreleasePool *pool = [NSAutoreleasePool new];
+ *scaleFactor = 1;
+ char* scaledFile = nil;
+- __block float screenScaleFactor = 1;
+-
+- [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
+- screenScaleFactor = [SplashNSScreen() backingScaleFactor];
+- }];
++ float screenScaleFactor = 1;
+
+ if (screenScaleFactor > 1) {
+ NSString *fileName = [NSString stringWithUTF8String: file];
+--- ./jdk/src/macosx/native/sun/font/AWTStrike.m Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/macosx/native/sun/font/AWTStrike.m Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -25,14 +25,11 @@
+
+ #import <JavaNativeFoundation/JavaNativeFoundation.h>
+ #import "java_awt_geom_PathIterator.h"
+-#import "sun_awt_SunHints.h"
+ #import "sun_font_CStrike.h"
+ #import "sun_font_CStrikeDisposer.h"
+ #import "CGGlyphImages.h"
+ #import "CGGlyphOutlines.h"
+-#import "AWTStrike.h"
+ #import "CoreTextSupport.h"
+-//#import "jni_util.h"
+ #include "fontscalerdefs.h"
+
+ /* Use THIS_FILE when it is available. */
+@@ -65,10 +62,10 @@
+ invDevTx.b *= -1;
+ invDevTx.c *= -1;
+ fFontTx = CGAffineTransformConcat(CGAffineTransformConcat(tx, invDevTx), sInverseTX);
+- fDevTx = CGAffineTransformInvert(invDevTx);
++ fDevTx = CGAffineTransformInvert(CGAffineTransformConcat(invDevTx, sInverseTX));
+
+ // the "font size" is the square root of the determinant of the matrix
+- fSize = sqrt(abs(fFontTx.a * fFontTx.d - fFontTx.b * fFontTx.c));
++ fSize = sqrt(fabs(fFontTx.a * fFontTx.d - fFontTx.b * fFontTx.c));
+ }
+ return self;
+ }
+--- ./jdk/src/share/classes/com/sun/crypto/provider/RSACipher.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/com/sun/crypto/provider/RSACipher.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -349,7 +349,7 @@
+ switch (mode) {
+ case MODE_SIGN:
+ data = padding.pad(buffer, 0, bufOfs);
+- return RSACore.rsa(data, privateKey);
++ return RSACore.rsa(data, privateKey, true);
+ case MODE_VERIFY:
+ byte[] verifyBuffer = RSACore.convert(buffer, 0, bufOfs);
+ data = RSACore.rsa(verifyBuffer, publicKey);
+@@ -359,7 +359,7 @@
+ return RSACore.rsa(data, publicKey);
+ case MODE_DECRYPT:
+ byte[] decryptBuffer = RSACore.convert(buffer, 0, bufOfs);
+- data = RSACore.rsa(decryptBuffer, privateKey);
++ data = RSACore.rsa(decryptBuffer, privateKey, false);
+ return padding.unpad(data);
+ default:
+ throw new AssertionError("Internal error");
+--- ./jdk/src/share/classes/java/awt/EventQueue.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/java/awt/EventQueue.java Thu Feb 05 13:00:26 2015 +0100
+@@ -182,7 +182,14 @@
+
+ private FwDispatcher fwDispatcher;
+
+- private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.EventQueue");
++ private static volatile PlatformLogger eventLog;
++
++ private static final PlatformLogger getEventLog() {
++ if(eventLog == null) {
++ eventLog = PlatformLogger.getLogger("java.awt.event.EventQueue");
++ }
++ return eventLog;
++ }
+
+ static {
+ AWTAccessor.setEventQueueAccessor(
+@@ -759,8 +766,8 @@
+ dispatchThread.stopDispatching();
+ }
+ } else {
+- if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
+- eventLog.fine("Unable to dispatch event: " + event);
++ if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
++ getEventLog().fine("Unable to dispatch event: " + event);
+ }
+ }
+ }
+@@ -857,8 +864,8 @@
+ * @since 1.2
+ */
+ public void push(EventQueue newEventQueue) {
+- if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
+- eventLog.fine("EventQueue.push(" + newEventQueue + ")");
++ if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
++ getEventLog().fine("EventQueue.push(" + newEventQueue + ")");
+ }
+
+ pushPopLock.lock();
+@@ -883,8 +890,8 @@
+ // Use getNextEventPrivate() as it doesn't call flushPendingEvents()
+ newEventQueue.postEventPrivate(topQueue.getNextEventPrivate());
+ } catch (InterruptedException ie) {
+- if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
+- eventLog.fine("Interrupted push", ie);
++ if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
++ getEventLog().fine("Interrupted push", ie);
+ }
+ }
+ }
+@@ -922,8 +929,8 @@
+ * @since 1.2
+ */
+ protected void pop() throws EmptyStackException {
+- if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
+- eventLog.fine("EventQueue.pop(" + this + ")");
++ if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
++ getEventLog().fine("EventQueue.pop(" + this + ")");
+ }
+
+ pushPopLock.lock();
+@@ -945,8 +952,8 @@
+ try {
+ prevQueue.postEventPrivate(topQueue.getNextEventPrivate());
+ } catch (InterruptedException ie) {
+- if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
+- eventLog.fine("Interrupted pop", ie);
++ if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
++ getEventLog().fine("Interrupted pop", ie);
+ }
+ }
+ }
+--- ./jdk/src/share/classes/java/beans/Beans.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/java/beans/Beans.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1996, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -46,9 +46,6 @@
+
+ import java.net.URL;
+
+-import java.security.AccessController;
+-import java.security.PrivilegedAction;
+-
+ import java.util.Enumeration;
+ import java.util.Hashtable;
+ import java.util.Iterator;
+@@ -179,16 +176,10 @@
+
+ // Try to find a serialized object with this name
+ final String serName = beanName.replace('.','/').concat(".ser");
+- final ClassLoader loader = cls;
+- ins = AccessController.doPrivileged
+- (new PrivilegedAction<InputStream>() {
+- public InputStream run() {
+- if (loader == null)
+- return ClassLoader.getSystemResourceAsStream(serName);
+- else
+- return loader.getResourceAsStream(serName);
+- }
+- });
++ if (cls == null)
++ ins = ClassLoader.getSystemResourceAsStream(serName);
++ else
++ ins = cls.getResourceAsStream(serName);
+ if (ins != null) {
+ try {
+ if (cls == null) {
+@@ -279,19 +270,10 @@
+ URL docBase = null;
+
+ // Now get the URL correponding to the resource name.
+-
+- final ClassLoader cloader = cls;
+- objectUrl =
+- AccessController.doPrivileged
+- (new PrivilegedAction<URL>() {
+- public URL run() {
+- if (cloader == null)
+- return ClassLoader.getSystemResource
+- (resourceName);
+- else
+- return cloader.getResource(resourceName);
+- }
+- });
++ if (cls == null) {
++ objectUrl = ClassLoader.getSystemResource(resourceName);
++ } else
++ objectUrl = cls.getResource(resourceName);
+
+ // If we found a URL, we try to locate the docbase by taking
+ // of the final path name component, and the code base by taking
+--- ./jdk/src/share/classes/java/beans/SimpleBeanInfo.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/java/beans/SimpleBeanInfo.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1996, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -25,6 +25,11 @@
+
+ package java.beans;
+
++import java.awt.Image;
++import java.awt.Toolkit;
++import java.awt.image.ImageProducer;
++import java.net.URL;
++
+ /**
+ * This is a support class to make it easier for people to provide
+ * BeanInfo classes.
+@@ -99,7 +104,7 @@
+ * Claim there are no icons available. You can override
+ * this if you want to provide icons for your bean.
+ */
+- public java.awt.Image getIcon(int iconKind) {
++ public Image getIcon(int iconKind) {
+ return null;
+ }
+
+@@ -114,33 +119,17 @@
+ * "wombat.gif".
+ * @return an image object. May be null if the load failed.
+ */
+- public java.awt.Image loadImage(final String resourceName) {
++ public Image loadImage(final String resourceName) {
+ try {
+- final Class<?> c = getClass();
+- java.awt.image.ImageProducer ip = (java.awt.image.ImageProducer)
+- java.security.AccessController.doPrivileged(
+- new java.security.PrivilegedAction<Object>() {
+- public Object run() {
+- java.net.URL url;
+- if ((url = c.getResource(resourceName)) == null) {
+- return null;
+- } else {
+- try {
+- return url.getContent();
+- } catch (java.io.IOException ioe) {
+- return null;
+- }
+- }
+- }
+- });
+-
+- if (ip == null)
+- return null;
+- java.awt.Toolkit tk = java.awt.Toolkit.getDefaultToolkit();
+- return tk.createImage(ip);
+- } catch (Exception ex) {
+- return null;
++ final URL url = getClass().getResource(resourceName);
++ if (url != null) {
++ final ImageProducer ip = (ImageProducer) url.getContent();
++ if (ip != null) {
++ return Toolkit.getDefaultToolkit().createImage(ip);
++ }
++ }
++ } catch (final Exception ignored) {
+ }
++ return null;
+ }
+-
+ }
+--- ./jdk/src/share/classes/java/net/SocksSocketImpl.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/java/net/SocksSocketImpl.java Thu Feb 05 13:00:26 2015 +0100
+@@ -388,14 +388,13 @@
+ }
+ while (iProxy.hasNext()) {
+ p = iProxy.next();
+- if (p == null || p == Proxy.NO_PROXY) {
++ if (p == null || p.type() != Proxy.Type.SOCKS) {
+ super.connect(epoint, remainingMillis(deadlineMillis));
+ return;
+ }
+- if (p.type() != Proxy.Type.SOCKS)
+- throw new SocketException("Unknown proxy type : " + p.type());
++
+ if (!(p.address() instanceof InetSocketAddress))
+- throw new SocketException("Unknow address type for proxy: " + p);
++ throw new SocketException("Unknown address type for proxy: " + p);
+ // Use getHostString() to avoid reverse lookups
+ server = ((InetSocketAddress) p.address()).getHostString();
+ serverPort = ((InetSocketAddress) p.address()).getPort();
+@@ -703,13 +702,12 @@
+ }
+ while (iProxy.hasNext()) {
+ p = iProxy.next();
+- if (p == null || p == Proxy.NO_PROXY) {
++ if (p == null || p.type() != Proxy.Type.SOCKS) {
+ return;
+ }
+- if (p.type() != Proxy.Type.SOCKS)
+- throw new SocketException("Unknown proxy type : " + p.type());
++
+ if (!(p.address() instanceof InetSocketAddress))
+- throw new SocketException("Unknow address type for proxy: " + p);
++ throw new SocketException("Unknown address type for proxy: " + p);
+ // Use getHostString() to avoid reverse lookups
+ server = ((InetSocketAddress) p.address()).getHostString();
+ serverPort = ((InetSocketAddress) p.address()).getPort();
+--- ./jdk/src/share/classes/sun/security/krb5/Config.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/krb5/Config.java Thu Feb 05 13:00:26 2015 +0100
+@@ -763,9 +763,9 @@
+
+ private static String trimmed(String s) {
+ s = s.trim();
+- if (s.isEmpty()) return s;
+- if (s.charAt(0) == '"' && s.charAt(s.length()-1) == '"' ||
+- s.charAt(0) == '\'' && s.charAt(s.length()-1) == '\'') {
++ if (s.length() >= 2 &&
++ ((s.charAt(0) == '"' && s.charAt(s.length()-1) == '"') ||
++ (s.charAt(0) == '\'' && s.charAt(s.length()-1) == '\''))) {
+ s = s.substring(1, s.length()-1).trim();
+ }
+ return s;
+--- ./jdk/src/share/classes/sun/security/pkcs12/PKCS12KeyStore.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/pkcs12/PKCS12KeyStore.java Thu Feb 05 13:00:26 2015 +0100
+@@ -707,6 +707,11 @@
+
+ entry.protectedPrivKey = key.clone();
+ if (chain != null) {
++ // validate cert-chain
++ if ((chain.length > 1) && (!validateChain(chain))) {
++ throw new KeyStoreException("Certificate chain is "
++ + "not valid");
++ }
+ entry.chain = chain.clone();
+ certificateCount += chain.length;
+
+@@ -1448,7 +1453,12 @@
+ if (!(issuerDN.equals(subjectDN)))
+ return false;
+ }
+- return true;
++
++ // Check for loops in the chain. If there are repeated certs,
++ // the Set of certs in the chain will contain fewer certs than
++ // the chain
++ Set<Certificate> set = new HashSet<>(Arrays.asList(certChain));
++ return set.size() == certChain.length;
+ }
+
+
+@@ -2022,7 +2032,24 @@
+ ArrayList<X509Certificate> chain =
+ new ArrayList<X509Certificate>();
+ X509Certificate cert = findMatchedCertificate(entry);
++
++ mainloop:
+ while (cert != null) {
++ // Check for loops in the certificate chain
++ if (!chain.isEmpty()) {
++ for (X509Certificate chainCert : chain) {
++ if (cert.equals(chainCert)) {
++ if (debug != null) {
++ debug.println("Loop detected in " +
++ "certificate chain. Skip adding " +
++ "repeated cert to chain. Subject: " +
++ cert.getSubjectX500Principal()
++ .toString());
++ }
++ break mainloop;
++ }
++ }
++ }
+ chain.add(cert);
+ X500Principal issuerDN = cert.getIssuerX500Principal();
+ if (issuerDN.equals(cert.getSubjectX500Principal())) {
+--- ./jdk/src/share/classes/sun/security/provider/certpath/DistributionPointFetcher.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/provider/certpath/DistributionPointFetcher.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2002, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -541,10 +541,10 @@
+ // set interim reasons mask to the intersection of
+ // reasons in the DP and onlySomeReasons in the IDP
+ boolean[] idpReasonFlags = reasons.getFlags();
+- for (int i = 0; i < idpReasonFlags.length; i++) {
+- if (idpReasonFlags[i] && pointReasonFlags[i]) {
+- interimReasonsMask[i] = true;
+- }
++ for (int i = 0; i < interimReasonsMask.length; i++) {
++ interimReasonsMask[i] =
++ (i < idpReasonFlags.length && idpReasonFlags[i]) &&
++ (i < pointReasonFlags.length && pointReasonFlags[i]);
+ }
+ } else {
+ // set interim reasons mask to the value of
+@@ -558,7 +558,6 @@
+ interimReasonsMask = pointReasonFlags.clone();
+ } else {
+ // set interim reasons mask to the special value all-reasons
+- interimReasonsMask = new boolean[9];
+ Arrays.fill(interimReasonsMask, true);
+ }
+ }
+@@ -567,7 +566,9 @@
+ // not included in the reasons mask
+ boolean oneOrMore = false;
+ for (int i = 0; i < interimReasonsMask.length && !oneOrMore; i++) {
+- if (!reasonsMask[i] && interimReasonsMask[i]) {
++ if (interimReasonsMask[i] &&
++ !(i < reasonsMask.length && reasonsMask[i]))
++ {
+ oneOrMore = true;
+ }
+ }
+@@ -693,11 +694,11 @@
+ }
+
+ // update reasonsMask
+- for (int i = 0; i < interimReasonsMask.length; i++) {
+- if (!reasonsMask[i] && interimReasonsMask[i]) {
+- reasonsMask[i] = true;
+- }
++ for (int i = 0; i < reasonsMask.length; i++) {
++ reasonsMask[i] = reasonsMask[i] ||
++ (i < interimReasonsMask.length && interimReasonsMask[i]);
+ }
++
+ return true;
+ }
+
+--- ./jdk/src/share/classes/sun/security/rsa/RSACore.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/rsa/RSACore.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -102,12 +102,24 @@
+
+ /**
+ * Perform an RSA private key operation. Uses CRT if the key is a
+- * CRT key.
++ * CRT key with additional verification check after the signature
++ * is computed.
+ */
++ @Deprecated
+ public static byte[] rsa(byte[] msg, RSAPrivateKey key)
+ throws BadPaddingException {
++ return rsa(msg, key, true);
++ }
++
++ /**
++ * Perform an RSA private key operation. Uses CRT if the key is a
++ * CRT key. Set 'verify' to true if this function is used for
++ * generating a signature.
++ */
++ public static byte[] rsa(byte[] msg, RSAPrivateKey key, boolean verify)
++ throws BadPaddingException {
+ if (key instanceof RSAPrivateCrtKey) {
+- return crtCrypt(msg, (RSAPrivateCrtKey)key);
++ return crtCrypt(msg, (RSAPrivateCrtKey)key, verify);
+ } else {
+ return priCrypt(msg, key.getModulus(), key.getPrivateExponent());
+ }
+@@ -148,10 +160,11 @@
+ * RSA private key operations with CRT. Algorithm and variable naming
+ * are taken from PKCS#1 v2.1, section 5.1.2.
+ */
+- private static byte[] crtCrypt(byte[] msg, RSAPrivateCrtKey key)
+- throws BadPaddingException {
++ private static byte[] crtCrypt(byte[] msg, RSAPrivateCrtKey key,
++ boolean verify) throws BadPaddingException {
+ BigInteger n = key.getModulus();
+- BigInteger c = parseMsg(msg, n);
++ BigInteger c0 = parseMsg(msg, n);
++ BigInteger c = c0;
+ BigInteger p = key.getPrimeP();
+ BigInteger q = key.getPrimeQ();
+ BigInteger dP = key.getPrimeExponentP();
+@@ -184,6 +197,9 @@
+ if (ENABLE_BLINDING) {
+ m = m.multiply(brp.v).mod(n);
+ }
++ if (verify && !c0.equals(m.modPow(e, n))) {
++ throw new BadPaddingException("RSA private key operation failed");
++ }
+
+ return toByteArray(m, getByteLength(n));
+ }
+--- ./jdk/src/share/classes/sun/security/rsa/RSASignature.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/rsa/RSASignature.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -173,7 +173,7 @@
+ try {
+ byte[] encoded = encodeSignature(digestOID, digest);
+ byte[] padded = padding.pad(encoded);
+- byte[] encrypted = RSACore.rsa(padded, privateKey);
++ byte[] encrypted = RSACore.rsa(padded, privateKey, true);
+ return encrypted;
+ } catch (GeneralSecurityException e) {
+ throw new SignatureException("Could not sign data", e);
+--- ./jdk/src/share/classes/sun/security/ssl/ClientHandshaker.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/ssl/ClientHandshaker.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1996, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -289,7 +289,7 @@
+ case K_ECDH_RSA:
+ throw new SSLProtocolException(
+ "Protocol violation: server sent a server key exchange"
+- + "message for key exchange " + keyExchange);
++ + " message for key exchange " + keyExchange);
+ case K_KRB5:
+ case K_KRB5_EXPORT:
+ throw new SSLProtocolException(
+--- ./jdk/src/share/classes/sun/security/ssl/Handshaker.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/ssl/Handshaker.java Thu Feb 05 13:00:26 2015 +0100
+@@ -697,6 +697,16 @@
+ continue;
+ }
+
++ if (!algorithmConstraints.permits(
++ EnumSet.of(CryptoPrimitive.KEY_AGREEMENT),
++ protocol.name, null)) {
++ if (debug != null && Debug.isOn("verbose")) {
++ System.out.println(
++ "Ignoring disabled protocol: " + protocol);
++ }
++
++ continue;
++ }
+ boolean found = false;
+ for (CipherSuite suite : enabledCipherSuites.collection()) {
+ if (suite.isAvailable() && suite.obsoleted > protocol.v &&
+--- ./jdk/src/share/classes/sun/security/util/HostnameChecker.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/util/HostnameChecker.java Thu Feb 05 13:00:26 2015 +0100
+@@ -26,6 +26,8 @@
+ package sun.security.util;
+
+ import java.io.IOException;
++import java.net.InetAddress;
++import java.net.UnknownHostException;
+ import java.util.*;
+
+ import java.security.Principal;
+@@ -148,6 +150,17 @@
+ String ipAddress = (String)next.get(1);
+ if (expectedIP.equalsIgnoreCase(ipAddress)) {
+ return;
++ } else {
++ // compare InetAddress objects in order to ensure
++ // equality between a long IPv6 address and its
++ // abbreviated form.
++ try {
++ if (InetAddress.getByName(expectedIP).equals(
++ InetAddress.getByName(ipAddress))) {
++ return;
++ }
++ } catch (UnknownHostException e) {
++ } catch (SecurityException e) {}
+ }
+ }
+ }
+--- ./jdk/src/share/classes/sun/security/x509/KeyUsageExtension.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/x509/KeyUsageExtension.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -83,7 +83,8 @@
+ * @param position the position in the bit string to check.
+ */
+ private boolean isSet(int position) {
+- return bitString[position];
++ return (position < bitString.length) &&
++ bitString[position];
+ }
+
+ /**
+@@ -275,41 +276,40 @@
+ * Returns a printable representation of the KeyUsage.
+ */
+ public String toString() {
+- String s = super.toString() + "KeyUsage [\n";
++ StringBuilder sb = new StringBuilder();
++ sb.append(super.toString());
++ sb.append("KeyUsage [\n");
+
+- try {
+- if (isSet(0)) {
+- s += " DigitalSignature\n";
+- }
+- if (isSet(1)) {
+- s += " Non_repudiation\n";
+- }
+- if (isSet(2)) {
+- s += " Key_Encipherment\n";
+- }
+- if (isSet(3)) {
+- s += " Data_Encipherment\n";
+- }
+- if (isSet(4)) {
+- s += " Key_Agreement\n";
+- }
+- if (isSet(5)) {
+- s += " Key_CertSign\n";
+- }
+- if (isSet(6)) {
+- s += " Crl_Sign\n";
+- }
+- if (isSet(7)) {
+- s += " Encipher_Only\n";
+- }
+- if (isSet(8)) {
+- s += " Decipher_Only\n";
+- }
+- } catch (ArrayIndexOutOfBoundsException ex) {}
++ if (isSet(0)) {
++ sb.append(" DigitalSignature\n");
++ }
++ if (isSet(1)) {
++ sb.append(" Non_repudiation\n");
++ }
++ if (isSet(2)) {
++ sb.append(" Key_Encipherment\n");
++ }
++ if (isSet(3)) {
++ sb.append(" Data_Encipherment\n");
++ }
++ if (isSet(4)) {
++ sb.append(" Key_Agreement\n");
++ }
++ if (isSet(5)) {
++ sb.append(" Key_CertSign\n");
++ }
++ if (isSet(6)) {
++ sb.append(" Crl_Sign\n");
++ }
++ if (isSet(7)) {
++ sb.append(" Encipher_Only\n");
++ }
++ if (isSet(8)) {
++ sb.append(" Decipher_Only\n");
++ }
++ sb.append("]\n");
+
+- s += "]\n";
+-
+- return (s);
++ return sb.toString();
+ }
+
+ /**
+--- ./jdk/src/share/classes/sun/security/x509/NetscapeCertTypeExtension.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/x509/NetscapeCertTypeExtension.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1998, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -136,7 +136,8 @@
+ * @param position the position in the bit string to check.
+ */
+ private boolean isSet(int position) {
+- return bitString[position];
++ return (position < bitString.length) &&
++ bitString[position];
+ }
+
+ /**
+@@ -236,27 +237,34 @@
+ * Returns a printable representation of the NetscapeCertType.
+ */
+ public String toString() {
+- String s = super.toString() + "NetscapeCertType [\n";
++ StringBuilder sb = new StringBuilder();
++ sb.append(super.toString());
++ sb.append("NetscapeCertType [\n");
+
+- try {
+- if (isSet(getPosition(SSL_CLIENT)))
+- s += " SSL client\n";
+- if (isSet(getPosition(SSL_SERVER)))
+- s += " SSL server\n";
+- if (isSet(getPosition(S_MIME)))
+- s += " S/MIME\n";
+- if (isSet(getPosition(OBJECT_SIGNING)))
+- s += " Object Signing\n";
+- if (isSet(getPosition(SSL_CA)))
+- s += " SSL CA\n";
+- if (isSet(getPosition(S_MIME_CA)))
+- s += " S/MIME CA\n";
+- if (isSet(getPosition(OBJECT_SIGNING_CA)))
+- s += " Object Signing CA" ;
+- } catch (Exception e) { }
++ if (isSet(0)) {
++ sb.append(" SSL client\n");
++ }
++ if (isSet(1)) {
++ sb.append(" SSL server\n");
++ }
++ if (isSet(2)) {
++ sb.append(" S/MIME\n");
++ }
++ if (isSet(3)) {
++ sb.append(" Object Signing\n");
++ }
++ if (isSet(5)) {
++ sb.append(" SSL CA\n");
++ }
++ if (isSet(6)) {
++ sb.append(" S/MIME CA\n");
++ }
++ if (isSet(7)) {
++ sb.append(" Object Signing CA");
++ }
+
+- s += "]\n";
+- return (s);
++ sb.append("]\n");
++ return sb.toString();
+ }
+
+ /**
+--- ./jdk/src/share/classes/sun/security/x509/ReasonFlags.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/security/x509/ReasonFlags.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -99,7 +99,8 @@
+ * @param position the position in the bit string to check.
+ */
+ private boolean isSet(int position) {
+- return bitString[position];
++ return (position < bitString.length) &&
++ bitString[position];
+ }
+
+ /**
+@@ -199,23 +200,38 @@
+ * Returns a printable representation of the ReasonFlags.
+ */
+ public String toString() {
+- String s = "Reason Flags [\n";
++ StringBuilder sb = new StringBuilder("Reason Flags [\n");
+
+- try {
+- if (isSet(0)) s += " Unused\n";
+- if (isSet(1)) s += " Key Compromise\n";
+- if (isSet(2)) s += " CA Compromise\n";
+- if (isSet(3)) s += " Affiliation_Changed\n";
+- if (isSet(4)) s += " Superseded\n";
+- if (isSet(5)) s += " Cessation Of Operation\n";
+- if (isSet(6)) s += " Certificate Hold\n";
+- if (isSet(7)) s += " Privilege Withdrawn\n";
+- if (isSet(8)) s += " AA Compromise\n";
+- } catch (ArrayIndexOutOfBoundsException ex) {}
++ if (isSet(0)) {
++ sb.append(" Unused\n");
++ }
++ if (isSet(1)) {
++ sb.append(" Key Compromise\n");
++ }
++ if (isSet(2)) {
++ sb.append(" CA Compromise\n");
++ }
++ if (isSet(3)) {
++ sb.append(" Affiliation_Changed\n");
++ }
++ if (isSet(4)) {
++ sb.append(" Superseded\n");
++ }
++ if (isSet(5)) {
++ sb.append(" Cessation Of Operation\n");
++ }
++ if (isSet(6)) {
++ sb.append(" Certificate Hold\n");
++ }
++ if (isSet(7)) {
++ sb.append(" Privilege Withdrawn\n");
++ }
++ if (isSet(8)) {
++ sb.append(" AA Compromise\n");
++ }
++ sb.append("]\n");
+
+- s += "]\n";
+-
+- return (s);
++ return sb.toString();
+ }
+
+ /**
+--- ./jdk/src/share/classes/sun/tools/jar/Main.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/tools/jar/Main.java Thu Feb 05 13:00:26 2015 +0100
+@@ -74,8 +74,10 @@
+ * Mflag: DO NOT generate a manifest file (just ZIP)
+ * iflag: generate jar index
+ * nflag: Perform jar normalization at the end
++ * pflag: preserve/don't strip leading slash and .. component from file name
++ *
+ */
+- boolean cflag, uflag, xflag, tflag, vflag, flag0, Mflag, iflag, nflag;
++ boolean cflag, uflag, xflag, tflag, vflag, flag0, Mflag, iflag, nflag, pflag;
+
+ static final String MANIFEST_DIR = "META-INF/";
+ static final String VERSION = "1.0";
+@@ -187,6 +189,7 @@
+ addMainClass(manifest, ename);
+ }
+ }
++ expand(null, files, false);
+ OutputStream out;
+ if (fname != null) {
+ out = new FileOutputStream(fname);
+@@ -208,13 +211,12 @@
+ tmpfile = createTemporaryFile(tmpbase, ".jar");
+ out = new FileOutputStream(tmpfile);
+ }
+- expand(null, files, false);
+ create(new BufferedOutputStream(out, 4096), manifest);
+ if (in != null) {
+ in.close();
+ }
+ out.close();
+- if(nflag) {
++ if (nflag) {
+ JarFile jarFile = null;
+ File packFile = null;
+ JarOutputStream jos = null;
+@@ -291,7 +293,7 @@
+ list(fname, files);
+ } else {
+ InputStream in = new FileInputStream(FileDescriptor.in);
+- try{
++ try {
+ list(new BufferedInputStream(in), files);
+ } finally {
+ in.close();
+@@ -410,6 +412,9 @@
+ case 'e':
+ ename = args[count++];
+ break;
++ case 'P':
++ pflag = true;
++ break;
+ default:
+ error(formatMsg("error.illegal.option",
+ String.valueOf(flags.charAt(i))));
+@@ -662,7 +667,6 @@
+ return updateOk;
+ }
+
+-
+ private void addIndex(JarIndex index, ZipOutputStream zos)
+ throws IOException
+ {
+@@ -699,6 +703,47 @@
+ return true;
+ }
+
++ private static final boolean isWinDriveLetter(char c) {
++ return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'));
++ }
++
++ private String safeName(String name) {
++ if (!pflag) {
++ int len = name.length();
++ int i = name.lastIndexOf("../");
++ if (i == -1) {
++ i = 0;
++ } else {
++ i += 3; // strip any dot-dot components
++ }
++ if (File.separatorChar == '\\') {
++ // the spec requests no drive letter. skip if
++ // the entry name has one.
++ while (i < len) {
++ int off = i;
++ if (i + 1 < len &&
++ name.charAt(i + 1) == ':' &&
++ isWinDriveLetter(name.charAt(i))) {
++ i += 2;
++ }
++ while (i < len && name.charAt(i) == '/') {
++ i++;
++ }
++ if (i == off) {
++ break;
++ }
++ }
++ } else {
++ while (i < len && name.charAt(i) == '/') {
++ i++;
++ }
++ }
++ if (i != 0) {
++ name = name.substring(i);
++ }
++ }
++ return name;
++ }
+
+ private String entryName(String name) {
+ name = name.replace(File.separatorChar, '/');
+@@ -710,10 +755,10 @@
+ }
+ }
+ name = name.substring(matchPath.length());
+-
+- if (name.startsWith("/")) {
+- name = name.substring(1);
+- } else if (name.startsWith("./")) {
++ name = safeName(name);
++ // the old implementaton doesn't remove
++ // "./" if it was led by "/" (?)
++ if (name.startsWith("./")) {
+ name = name.substring(2);
+ }
+ return name;
+@@ -913,8 +958,11 @@
+ for (ZipEntry ze : zes) {
+ long lastModified = ze.getTime();
+ if (lastModified != -1) {
+- File f = new File(ze.getName().replace('/', File.separatorChar));
+- f.setLastModified(lastModified);
++ String name = safeName(ze.getName().replace(File.separatorChar, '/'));
++ if (name.length() != 0) {
++ File f = new File(name.replace('/', File.separatorChar));
++ f.setLastModified(lastModified);
++ }
+ }
+ }
+ }
+@@ -958,7 +1006,6 @@
+ Enumeration<? extends ZipEntry> zes = zf.entries();
+ while (zes.hasMoreElements()) {
+ ZipEntry e = zes.nextElement();
+- InputStream is;
+ if (files == null) {
+ dirs.add(extractFile(zf.getInputStream(e), e));
+ } else {
+@@ -982,8 +1029,16 @@
+ */
+ ZipEntry extractFile(InputStream is, ZipEntry e) throws IOException {
+ ZipEntry rc = null;
+- String name = e.getName();
+- File f = new File(e.getName().replace('/', File.separatorChar));
++ // The spec requres all slashes MUST be forward '/', it is possible
++ // an offending zip/jar entry may uses the backwards slash in its
++ // name. It might cause problem on Windows platform as it skips
++ // our "safe" check for leading slahs and dot-dot. So replace them
++ // with '/'.
++ String name = safeName(e.getName().replace(File.separatorChar, '/'));
++ if (name.length() == 0) {
++ return rc; // leading '/' or 'dot-dot' only path
++ }
++ File f = new File(name.replace('/', File.separatorChar));
+ if (e.isDirectory()) {
+ if (f.exists()) {
+ if (!f.isDirectory()) {
+--- ./jdk/src/share/classes/sun/tools/jar/resources/jar.properties Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/tools/jar/resources/jar.properties Thu Feb 05 13:00:26 2015 +0100
+@@ -68,7 +68,7 @@
+ (in = {0}) (out= {1})
+
+ usage=\
+-Usage: jar {ctxui}[vfmn0Me] [jar-file] [manifest-file] [entry-point] [-C dir] files ...\n\
++Usage: jar {ctxui}[vfmn0PMe] [jar-file] [manifest-file] [entry-point] [-C dir] files ...\n\
+ Options:\n\
+ \ \ -c create new archive\n\
+ \ \ -t list table of contents for archive\n\
+@@ -81,6 +81,7 @@
+ \ \ -e specify application entry point for stand-alone application \n\
+ \ \ bundled into an executable jar file\n\
+ \ \ -0 store only; use no ZIP compression\n\
++\ \ -P preserve leading '/' (absolute path) and ".." (parent directory) components from file names\n\
+ \ \ -M do not create a manifest file for the entries\n\
+ \ \ -i generate index information for the specified jar files\n\
+ \ \ -C change to the specified directory and include the following file\n\
+--- ./jdk/src/share/classes/sun/util/resources/TimeZoneNames.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/TimeZoneNames.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1996, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -408,7 +408,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"Venezuela Time", "VET",
+ "Venezuela Summer Time", "VEST",
+ "Venezuela Time", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/de/TimeZoneNames_de.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/de/TimeZoneNames_de.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"Venezuelanische Zeit", "VET",
+ "Venezuelanische Sommerzeit", "VEST",
+ "Venezuelanische Zeit", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/es/TimeZoneNames_es.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/es/TimeZoneNames_es.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"Hora de Venezuela", "VET",
+ "Hora de verano de Venezuela", "VEST",
+ "Hora de Venezuela", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/fr/TimeZoneNames_fr.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/fr/TimeZoneNames_fr.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"Heure du Venezuela", "VET",
+ "Heure d'\u00e9t\u00e9 du Venezuela", "VEST",
+ "Heure du Venezuela", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/it/TimeZoneNames_it.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/it/TimeZoneNames_it.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"Ora del Venezuela", "VET",
+ "Ora estiva del Venezuela", "VEST",
+ "Ora del Venezuela", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/ja/TimeZoneNames_ja.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/ja/TimeZoneNames_ja.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"\u30d9\u30cd\u30ba\u30a8\u30e9\u6642\u9593", "VET",
+ "\u30d9\u30cd\u30ba\u30a8\u30e9\u590f\u6642\u9593", "VEST",
+ "\u30D9\u30CD\u30BA\u30A8\u30E9\u6642\u9593", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/ko/TimeZoneNames_ko.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/ko/TimeZoneNames_ko.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"\ubca0\ub124\uc218\uc5d8\ub77c \uc2dc\uac04", "VET",
+ "\ubca0\ub124\uc218\uc5d8\ub77c \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "VEST",
+ "\uBCA0\uB124\uC218\uC5D8\uB77C \uD45C\uC900\uC2DC", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/pt/TimeZoneNames_pt_BR.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/pt/TimeZoneNames_pt_BR.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"Fuso hor\u00e1rio da Venezuela", "VET",
+ "Fuso hor\u00e1rio de ver\u00e3o da Venezuela", "VEST",
+ "Hor\u00E1rio da Venezuela", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/sv/TimeZoneNames_sv.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/sv/TimeZoneNames_sv.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"Venezuela, normaltid", "VET",
+ "Venezuela, sommartid", "VEST",
+ "Venezuelansk tid", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/zh/TimeZoneNames_zh_CN.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/zh/TimeZoneNames_zh_CN.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"\u59d4\u5185\u745e\u62c9\u65f6\u95f4", "VET",
+ "\u59d4\u5185\u745e\u62c9\u590f\u4ee4\u65f6", "VEST",
+ "\u59D4\u5185\u745E\u62C9\u65F6\u95F4", "VET"}},
+--- ./jdk/src/share/classes/sun/util/resources/zh/TimeZoneNames_zh_TW.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/classes/sun/util/resources/zh/TimeZoneNames_zh_TW.java Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -409,7 +409,7 @@
+ {"America/Buenos_Aires", AGT},
+ {"America/Cambridge_Bay", MST},
+ {"America/Campo_Grande", AMT},
+- {"America/Cancun", CST},
++ {"America/Cancun", EST},
+ {"America/Caracas", new String[] {"\u59d4\u5167\u745e\u62c9\u6642\u9593", "VET",
+ "\u59d4\u5167\u745e\u62c9\u590f\u4ee4\u6642\u9593", "VEST",
+ "\u59D4\u5167\u745E\u62C9\u6642\u9593", "VET"}},
+--- ./jdk/src/share/native/sun/awt/libpng/CHANGES Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/CHANGES Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -23,8 +23,6 @@
+ * questions.
+ */
+
+-#if 0
+-libpng_changes(){ /*
+ CHANGES - changes for libpng
+
+ Version 0.2
+@@ -205,7 +203,7 @@
+ Fixed serious bug with < 8bpp images introduced in 0.95
+ Fixed 256-color transparency bug (Greg Roelofs)
+ Fixed up documentation (Greg Roelofs, Laszlo Nyul)
+- Fixed "error" in pngconf.h for Linux setjmp() behaviour
++ Fixed "error" in pngconf.h for Linux setjmp() behavior
+ Fixed DOS medium model support (Tim Wegner)
+ Fixed png_check_keyword() for case with error in static string text
+ Added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul)
+@@ -222,18 +220,20 @@
+ Added more typecasts. 65536L becomes (png_uint_32)65536L, etc. (Glenn R-P)
+ Minor corrections in libpng.txt
+ Added simple sRGB support (Glenn R-P)
+- Easier conditional compiling, e.g. define PNG_READ/WRITE_NOT_FULLY_SUPPORTED;
++ Easier conditional compiling, e.g.,
++ define PNG_READ/WRITE_NOT_FULLY_SUPPORTED;
+ all configurable options can be selected from command-line instead
+ of having to edit pngconf.h (Glenn R-P)
+ Fixed memory leak in pngwrite.c (free info_ptr->text) (Glenn R-P)
+ Added more conditions for png_do_background, to avoid changing
+ black pixels to background when a background is supplied and
+ no pixels are transparent
+- Repaired PNG_NO_STDIO behaviour
+- Tested NODIV support and made it default behaviour (Greg Roelofs)
++ Repaired PNG_NO_STDIO behavior
++ Tested NODIV support and made it default behavior (Greg Roelofs)
+ Added "-m" option and PNGTEST_DEBUG_MEMORY to pngtest (John Bowler)
+ Regularized version numbering scheme and bumped shared-library major
+- version number to 2 to avoid problems with libpng 0.89 apps (Greg Roelofs)
++ version number to 2 to avoid problems with libpng 0.89 apps
++ (Greg Roelofs)
+
+ Version 0.98 [January, 1998]
+ Cleaned up some typos in libpng.txt and in code documentation
+@@ -1803,7 +1803,7 @@
+ Removed AC_FUNC_MALLOC from configure.ac
+ Work around Intel-Mac compiler bug by setting PNG_NO_MMX_CODE in pngconf.h
+ Change "logical" to "bitwise" throughout documentation.
+- Detect and fix attempt to write wrong iCCP profile length.
++ Detect and fix attempt to write wrong iCCP profile length (CVE-2006-7244)
+
+ Version 1.0.21, 1.2.13 [November 14, 2006]
+ Fix potential buffer overflow in sPLT chunk handler.
+@@ -2126,7 +2126,7 @@
+ png_decompress_chunk(), and remove "chunkdata" from parameter list.
+ Put a call to png_check_chunk_name() in png_read_chunk_header().
+ Revised png_check_chunk_name() to reject a name with a lowercase 3rd byte.
+- Removed two calls to png_check_chunk_name() occurring later in the process.
++ Removed two calls to png_check_chunk_name() occuring later in the process.
+ Define PNG_NO_ERROR_NUMBERS by default in pngconf.h
+
+ Version 1.4.0beta25 [July 30, 2008]
+@@ -2386,7 +2386,7 @@
+
+ Version 1.4.0beta73 [August 1, 2009]
+ Reject attempt to write iCCP chunk with negative embedded profile length
+- (JD Chen)
++ (JD Chen) (CVE-2009-5063).
+
+ Version 1.4.0beta74 [August 8, 2009]
+ Changed png_ptr and info_ptr member "trans" to "trans_alpha".
+@@ -3174,8 +3174,8 @@
+ in version 1.5.0beta36 but is not noted in the CHANGES. Similarly,
+ it was changed from png_charpp to png_const_bytepp in png_set_iCCP().
+ Ensure that png_rgb_to_gray ignores palette mapped images, if libpng
+- internally happens to call it with one.
+- Fixed a failure to handle palette mapped images correctly.
++ internally happens to call it with one, and fixed a failure to handle
++ palette mapped images correctly. This fixes CVE-2690.
+
+ Version 1.5.1beta02 [January 14, 2011]
+ Fixed a bug in handling of interlaced images (bero at arklinux.org).
+@@ -3314,8 +3314,8 @@
+
+ Version 1.5.3beta01 [April 1, 2011]
+ Re-initialize the zlib compressor before compressing non-IDAT chunks.
+- Added API functions to set parameters for zlib compression of non-IDAT
+- chunks.
++ Added API functions (png_set_text_compression_level() and four others) to
++ set parameters for zlib compression of non-IDAT chunks.
+
+ Version 1.5.3beta02 [April 3, 2011]
+ Updated scripts/symbols.def with new API functions.
+@@ -3372,7 +3372,7 @@
+ dependency of the tIME-supporting RFC1132 code on stdio is removed and
+ PNG_NO_WARNINGS does actually work now.
+ Pass "" instead of '\0' to png_default_error() in png_err(). This mistake
+- was introduced in libpng-1.2.20beta01.
++ was introduced in libpng-1.2.20beta01. This fixes CVE-2011-2691.
+ Added PNG_WRITE_OPTIMIZE_CMF_SUPPORTED macro to make the zlib "CMF" byte
+ optimization configureable.
+ IDAT compression failed if preceded by a compressed text chunk (bug
+@@ -3403,7 +3403,8 @@
+ Documented png_set_alpha_mode(), other changes in libpng.3/libpng-manual.txt
+ The cHRM chunk now sets the defaults for png_set_rgb_to_gray() (when negative
+ parameters are supplied by the caller), while in the absence of cHRM
+- sRGB/Rec 709 values are still used.
++ sRGB/Rec 709 values are still used. This introduced a divide-by-zero
++ bug in png_handle_cHRM().
+ The bKGD chunk no longer overwrites the background value set by
+ png_set_background(), allowing the latter to be used before the file
+ header is read. It never performed any useful function to override
+@@ -3443,7 +3444,8 @@
+ Frank Busse, CVE-2011-2501, related to CVE-2004-0421).
+
+ Version 1.5.3beta11 [June 11, 2011]
+- Fixed png_handle_sCAL which is broken in 1.5; added sCAL to pngtest.png
++ Fixed png_handle_sCAL which is broken in 1.5. This fixes CVE 2011-2692.
++ Added sCAL to pngtest.png
+ Revised documentation about png_set_user_limits() to say that it also affects
+ png writing.
+ Revised handling of png_set_user_limits() so that it can increase the
+@@ -3468,7 +3470,7 @@
+ Removed string/memory macros that are no longer used and are not
+ necessarily fully supportable, particularly png_strncpy and png_snprintf.
+ Added log option to pngvalid.c and attempted to improve gamma messages.
+-
++
+ Version 1.5.3 [omitted]
+ People found the presence of a beta release following an rc release
+ to be confusing; therefore we bump the version to libpng-1.5.4beta01
+@@ -3532,6 +3534,1620 @@
+ Define PNG_ALLOCATED to "restrict" only if MSC_VER >= 1400.
+
+ Version 1.5.4 [July 7, 2011]
++ No changes.
++
++Version 1.5.5beta01 [July 13, 2011]
++ Fixed some typos and made other minor changes in the manual.
++ Updated contrib/pngminus/makefile.std (Samuli Souminen)
++
++Version 1.5.5beta02 [July 14, 2011]
++ Revised Makefile.am and Makefile.in to look in the right directory for
++ pnglibconf.h.prebuilt
++
++Version 1.5.5beta03 [July 27, 2011]
++ Enabled compilation with g++ compiler. This compiler does not recognize
++ the file extension, so it always compiles with C++ rules. Made minor
++ changes to pngrutil.c to cast results where C++ expects it but C does not.
++ Minor editing of libpng.3 and libpng-manual.txt.
++
++Version 1.5.5beta04 [July 29, 2011]
++ Revised CMakeLists.txt (Clifford Yapp)
++ Updated commentary about the png_rgb_to_gray() default coefficients
++ in the manual and in pngrtran.c
++
++Version 1.5.5beta05 [August 17, 2011]
++ Prevent unexpected API exports from non-libpng DLLs on Windows. The "_DLL"
++ is removed from the test of whether a DLL is being built (this erroneously
++ caused the libpng APIs to be marked as DLL exports in static builds under
++ Microsoft Visual Studio). Almost all of the libpng building configuration
++ is moved from pngconf.h to pngpriv.h, but PNG_DLL_EXPORT remains in
++ pngconf.h, though, so that it is colocated with the import definition (it
++ is no longer used anywhere in the installed headers). The VStudio project
++ definitions have been cleaned up: "_USRDLL" has been removed from the
++ static library builds (this was incorrect), and PNG_USE_DLL has been added
++ to pngvalid to test the functionality (pngtest does not supply it,
++ deliberately). The spurious "_EXPORTS" has been removed from the
++ libpng build (all these errors were a result of copy/paste between project
++ configurations.)
++ Added new types and internal functions for CIE RGB end point handling to
++ pngpriv.h (functions yet to be implemented).
++
++Version 1.5.5beta06 [August 26, 2011]
++ Ensure the CMAKE_LIBRARY_OUTPUT_DIRECTORY is set in CMakeLists.txt
++ (Clifford Yap)
++ Fixes to rgb_to_gray and cHRM XYZ APIs (John Bowler):
++ The rgb_to_gray code had errors when combined with gamma correction.
++ Some pixels were treated as true grey when they weren't and such pixels
++ and true grey ones were not gamma corrected (the original value of the
++ red component was used instead). APIs to get and set cHRM using color
++ space end points have been added and the rgb_to_gray code that defaults
++ based on cHRM, and the divide-by-zero bug in png_handle_cHRM (CERT
++ VU#477046, CVE-2011-3328, introduced in 1.5.4) have been corrected.
++ A considerable number of tests has been added to pngvalid for the
++ rgb_to_gray transform.
++ Arithmetic errors in rgb_to_gray whereby the calculated gray value was
++ truncated to the bit depth rather than rounded have been fixed except in
++ the 8-bit non-gamma-corrected case (where consistency seems more important
++ than correctness.) The code still has considerable inaccuracies in the
++ 8-bit case because 8-bit linear arithmetic is used.
++
++Version 1.5.5beta07 [September 7, 2011]
++ Added "$(ARCH)" option to makefile.darwin
++ Added SunOS support to configure.ac and Makefile.am
++ Changed png_chunk_benign_error() to png_warning() in png.c, in
++ png_XYZ_from_xy_checked().
++
++Version 1.5.5beta08 [September 10, 2011]
++ Fixed 64-bit compilation errors (gcc). The errors fixed relate
++ to conditions where types that are 32 bits in the GCC 32-bit
++ world (uLong and png_size_t) become 64 bits in the 64-bit
++ world. This produces potential truncation errors which the
++ compiler correctly flags.
++ Relocated new HAVE_SOLARIS_LD definition in configure.ac
++ Constant changes for 64-bit compatibility (removal of L suffixes). The
++ 16-bit cases still use "L" as we don't have a 16-bit test system.
++
++Version 1.5.5rc01 [September 15, 2011]
++ Removed "L" suffixes in pngpriv.h
++
++Version 1.5.5 [September 22, 2011]
++ No changes.
++
++Version 1.5.6beta01 [September 22, 2011]
++ Fixed some 64-bit type conversion warnings in pngrtran.c
++ Moved row_info from png_struct to a local variable.
++ The various interlace mask arrays have been made into arrays of
++ bytes and made PNG_CONST and static (previously some arrays were
++ marked PNG_CONST and some weren't).
++ Additional checks have been added to the transform code to validate the
++ pixel depths after the transforms on both read and write.
++ Removed some redundant code from pngwrite.c, in png_destroy_write_struct().
++ Changed chunk reading/writing code to use png_uint_32 instead of png_byte[4].
++ This removes the need to allocate temporary strings for chunk names on
++ the stack in the read/write code. Unknown chunk handling still uses the
++ string form because this is exposed in the API.
++
++Version 1.5.6beta02 [September 26, 2011]
++ Added a note in the manual the png_read_update_info() must be called only
++ once with a particular info_ptr.
++ Fixed a typo in the definition of the new PNG_STRING_FROM_CHUNK(s,c) macro.
++
++Version 1.5.6beta03 [September 28, 2011]
++ Revised test-pngtest.sh to report FAIL when pngtest fails.
++ Added "--strict" option to pngtest, to report FAIL when the failure is
++ only because the resulting valid files are different.
++ Revised CMakeLists.txt to work with mingw and removed some material from
++ CMakeLists.txt that is no longer useful in libpng-1.5.
++
++Version 1.5.6beta04 [October 5, 2011]
++ Fixed typo in Makefile.in and Makefile.am ("-M Wl" should be "-M -Wl")."
++
++Version 1.5.6beta05 [October 12, 2011]
++ Speed up png_combine_row() for interlaced images. This reduces the generality
++ of the code, allowing it to be optimized for Adam7 interlace. The masks
++ passed to png_combine_row() are now generated internally, avoiding
++ some code duplication and localizing the interlace handling somewhat.
++ Align png_struct::row_buf - previously it was always unaligned, caused by
++ a bug in the code that attempted to align it; the code needs to subtract
++ one from the pointer to take account of the filter byte prepended to
++ each row.
++ Optimized png_combine_row() when rows are aligned. This gains a small
++ percentage for 16-bit and 32-bit pixels in the typical case where the
++ output row buffers are appropriately aligned. The optimization was not
++ previously possible because the png_struct buffer was always misaligned.
++ Fixed bug in png_write_chunk_header() debug print, introduced in 1.5.6beta01.
++
++Version 1.5.6beta06 [October 17, 2011]
++ Removed two redundant tests for unitialized row.
++ Fixed a relatively harmless memory overwrite in compressed text writing
++ with a 1 byte zlib buffer.
++ Add ability to call png_read_update_info multiple times to pngvalid.c.
++ Fixes for multiple calls to png_read_update_info. These fixes attend to
++ most of the errors revealed in pngvalid, however doing the gamma work
++ twice results in inaccuracies that can't be easily fixed. There is now
++ a warning in the code if this is going to happen.
++ Turned on multiple png_read_update_info in pngvalid transform tests.
++ Prevent libpng from overwriting unused bits at the end of the image when
++ it is not byte aligned, while reading. Prior to libpng-1.5.6 libpng would
++ overwrite the partial byte at the end of each row if the row width was not
++ an exact multiple of 8 bits and the image is not interlaced.
++
++Version 1.5.6beta07 [October 21, 2011]
++ Made png_ptr->prev_row an aligned pointer into png_ptr->big_prev_row
++ (Mans Rullgard).
++
++Version 1.5.6rc01 [October 26, 2011]
++ Changed misleading "Missing PLTE before cHRM" warning to "Out of place cHRM"
++
++Version 1.5.6rc02 [October 27, 2011]
++ Added LSR() macro to defend against buggy compilers that evaluate non-taken
++ code branches and complain about out-of-range shifts.
++
++Version 1.5.6rc03 [October 28, 2011]
++ Renamed the LSR() macro to PNG_LSR() and added PNG_LSL() macro.
++ Fixed compiler warnings with Intel and MSYS compilers. The logical shift
++ fix for Microsoft Visual C is required by other compilers, so this
++ enables that fix for all compilers when using compile-time constants.
++ Under MSYS 'byte' is a name declared in a system header file, so we
++ changed the name of a local variable to avoid the warnings that result.
++ Added #define PNG_ALIGN_TYPE PNG_ALIGN_NONE to contrib/pngminim/*/pngusr.h
++
++Version 1.5.6 [November 3, 2011]
++ No changes.
++
++Version 1.5.7beta01 [November 4, 2011]
++ Added support for ARM processor, when decoding all PNG up-filtered rows
++ and any other-filtered rows with 3 or 4 bytes per pixel (Mans Rullgard).
++ Fixed bug in pngvalid on early allocation failure; fixed type cast in
++ pngmem.c; pngvalid would attempt to call png_error() if the allocation
++ of a png_struct or png_info failed. This would probably have led to a
++ crash. The pngmem.c implementation of png_malloc() included a cast
++ to png_size_t which would fail on large allocations on 16-bit systems.
++ Fix for the preprocessor of the Intel C compiler. The preprocessor
++ splits adjacent @ signs with a space; this changes the concatentation
++ token from @-@-@ to PNG_JOIN; that should work with all compiler
++ preprocessors.
++ Paeth filter speed improvements from work by Siarhei Siamashka. This
++ changes the 'Paeth' reconstruction function to improve the GCC code
++ generation on x86. The changes are only part of the suggested ones;
++ just the changes that definitely improve speed and remain simple.
++ The changes also slightly increase the clarity of the code.
++
++Version 1.5.7beta02 [November 11, 2011]
++ Check compression_type parameter in png_get_iCCP and remove spurious
++ casts. The compression_type parameter is always assigned to, so must
++ be non-NULL. The cast of the profile length potentially truncated the
++ value unnecessarily on a 16-bit int system, so the cast of the (byte)
++ compression type to (int) is specified by ANSI-C anyway.
++ Fixed FP division by zero in pngvalid.c; the 'test_pixel' code left
++ the sBIT fields in the test pixel as 0, which resulted in a floating
++ point division by zero which was irrelevant but causes systems where
++ FP exceptions cause a crash. Added code to pngvalid to turn on FP
++ exceptions if the appropriate glibc support is there to ensure this is
++ tested in the future.
++ Updated scripts/pnglibconf.mak and scripts/makefile.std to handle the
++ new PNG_JOIN macro.
++ Added versioning to pnglibconf.h comments.
++ Simplified read/write API initial version; basic read/write tested on
++ a variety of images, limited documentation (in the header file.)
++ Installed more accurate linear to sRGB conversion tables. The slightly
++ modified tables reduce the number of 16-bit values that
++ convert to an off-by-one 8-bit value. The "makesRGB.c" code that was used
++ to generate the tables is now in a contrib/sRGBtables sub-directory.
++
++Version 1.5.7beta03 [November 17, 2011]
++ Removed PNG_CONST from the sRGB table declarations in pngpriv.h and png.c
++ Added run-time detection of NEON support.
++ Added contrib/libtests; includes simplified API test and timing test and
++ a color conversion utility for rapid checking of failed 'pngstest' results.
++ Multiple transform bug fixes plus a work-round for double gamma correction.
++ libpng does not support more than one transform that requires linear data
++ at once - if this is tried typically the results is double gamma
++ correction. Since the simplified APIs can need rgb to gray combined with
++ a compose operation it is necessary to do one of these outside the main
++ libpng transform code. This check-in also contains fixes to various bugs
++ in the simplified APIs themselves and to some bugs in compose and rgb to
++ gray (on palette) itself.
++ Fixes for C++ compilation using g++ When libpng source is compiled
++ using g++. The compiler imposes C++ rules on the C source; thus it
++ is desireable to make the source work with either C or C++ rules
++ without throwing away useful error information. This change adds
++ png_voidcast to allow C semantic (void*) cases or the corresponding
++ C++ static_cast operation, as appropriate.
++ Added --noexecstack to assembler file compilation. GCC does not set
++ this on assembler compilation, even though it does on C compilation.
++ This creates security issues if assembler code is enabled; the
++ work-around is to set it by default in the flags for $(CCAS)
++ Work around compilers that don't support declaration of const data. Some
++ compilers fault 'extern const' data declarations (because the data is
++ not initialized); this turns on const-ness only for compilers where
++ this is known to work.
++
++Version 1.5.7beta04 [November 17, 2011]
++ Since the gcc driver does not recognize the --noexecstack flag, we must
++ use the -Wa prefix to have it passed through to the assembler.
++ Also removed a duplicate setting of this flag.
++ Added files that were omitted from the libpng-1.5.7beta03 zip distribution.
++
++Version 1.5.7beta05 [November 25, 2011]
++ Removed "zTXt" from warning in generic chunk decompression function.
++ Validate time settings passed to pngset() and png_convert_to_rfc1123()
++ (Frank Busse).
++ Added MINGW support to CMakeLists.txt
++ Reject invalid compression flag or method when reading the iTXt chunk.
++ Backed out 'simplified' API changes. The API seems too complex and there
++ is a lack of consensus or enthusiasm for the proposals. The API also
++ reveals significant bugs inside libpng (double gamma correction and the
++ known bug of being unable to retrieve a corrected palette). It seems
++ better to wait until the bugs, at least, are corrected.
++ Moved pngvalid.c into contrib/libtests
++ Rebuilt Makefile.in, configure, etc., with autoconf-2.68
++
++Version 1.5.7rc01 [December 1, 2011]
++ Replaced an "#if" with "#ifdef" in pngrtran.c
++ Revised #if PNG_DO_BC block in png.c (use #ifdef and add #else)
++
++Version 1.5.7rc02 [December 5, 2011]
++ Revised project files and contrib/pngvalid/pngvalid.c to account for
++ the relocation of pngvalid into contrib/libtests.
++ Revised pngconf.h to use " __declspec(restrict)" only when MSC_VER >= 1400,
++ as in libpng-1.5.4.
++ Put CRLF line endings in the owatcom project files.
++
++Version 1.5.7rc03 [December 7, 2011]
++ Updated CMakeLists.txt to account for the relocation of pngvalid.c
++
++Version 1.5.7 [December 15, 2011]
++ Minor fixes to pngvalid.c for gcc 4.6.2 compatibility to remove warnings
++ reported by earlier versions.
++ Fixed minor memset/sizeof errors in pngvalid.c.
++
++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 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.
++ Added ANSI-C (C90) headers and require them, and take advantage of the
++ change. Also fixed some of the projects/* and contrib/* files that needed
++ updates for libpng16 and the move of pngvalid.c.
++ With this change the required ANSI-C header files are assumed to exist: the
++ implementation must provide float.h, limits.h, stdarg.h and stddef.h and
++ libpng relies on limits.h and stddef.h existing and behaving as defined
++ (the other two required headers aren't used). Non-ANSI systems that don't
++ have stddef.h or limits.h will have to provide an appropriate fake
++ containing the relevant types and #defines.
++ The use of FAR/far has been eliminated and the definition of png_alloc_size_t
++ is now controlled by a flag so that 'small size_t' systems can select it
++ if necessary. Libpng 1.6 may not currently work on such systems -- it
++ seems likely that it will ask 'malloc' for more than 65535 bytes with any
++ image that has a sufficiently large row size (rather than simply failing
++ to read such images).
++ New tools directory containing tools used to generate libpng code.
++ Fixed race conditions in parallel make builds. With higher degrees of
++ parallelism during 'make' the use of the same temporary file names such
++ as 'dfn*' can result in a race where a temporary file from one arm of the
++ build is deleted or overwritten in another arm. This changes the
++ temporary files for suffix rules to always use $* and ensures that the
++ non-suffix rules use unique file names.
++
++Version 1.6.0beta02 [December 21, 2011]
++ Correct configure builds where build and source directories are separate.
++ The include path of 'config.h' was erroneously made relative in pngvalid.c
++ in libpng 1.5.7.
++
++Version 1.6.0beta03 [December 22, 2011]
++ Start-up code size improvements, error handler flexibility. These changes
++ alter how the tricky allocation of the initial png_struct and png_info
++ structures are handled. png_info is now handled in pretty much the same
++ way as everything else, except that the allocations handle NULL return
++ silently. png_struct is changed in a similar way on allocation and on
++ deallocation a 'safety' error handler is put in place (which should never
++ be required). The error handler itself is changed to permit mismatches
++ in the application and libpng error buffer size; however, this means a
++ silent change to the API to return the jmp_buf if the size doesn't match
++ the size from the libpng compilation; libpng now allocates the memory and
++ this may fail. Overall these changes result in slight code size
++ reductions; however, this is a reduction in code that is always executed
++ so is particularly valuable. Overall on a 64-bit system the libpng DLL
++ decreases in code size by 1733 bytes. pngerror.o increases in size by
++ about 465 bytes because of the new functionality.
++ Added png_convert_to_rfc1123_buffer() and deprecated png_convert_to_rfc1123()
++ to avoid including a spurious buffer in the png_struct.
++
++Version 1.6.0beta04 [December 30, 2011]
++ Regenerated configure scripts with automake-1.11.2
++ Eliminated png_info_destroy(). It is now used only in png.c and only calls
++ one other internal function and memset().
++ Enabled png_get_sCAL_fixed() if floating point APIs are enabled. Previously
++ it was disabled whenever internal fixed point arithmetic was selected,
++ which meant it didn't exist even on systems where FP was available but not
++ preferred.
++ Added pngvalid.c compile time checks for const APIs.
++ Implemented 'restrict' for png_info and png_struct. Because of the way
++ libpng works both png_info and png_struct are always accessed via a
++ single pointer. This means adding C99 'restrict' to the pointer gives
++ the compiler some opportunity to optimize the code. This change allows
++ that.
++ Moved AC_MSG_CHECKING([if libraries can be versioned]) later to the proper
++ location in configure.ac (Gilles Espinasse).
++ Changed png_memcpy to C assignment where appropriate. Changed all those
++ uses of png_memcpy that were doing a simple assignment to assignments
++ (all those cases where the thing being copied is a non-array C L-value).
++ Added some error checking to png_set_*() routines.
++ Removed the reference to the non-exported function png_memcpy() from
++ example.c.
++ Fixed the Visual C 64-bit build - it requires jmp_buf to be aligned, but
++ it had become misaligned.
++ Revised contrib/pngminus/pnm2png.c to avoid warnings when png_uint_32
++ and unsigned long are of different sizes.
++
++Version 1.6.0beta05 [January 15, 2012]
++ Updated manual with description of the simplified API (copied from png.h)
++ Fix bug in pngerror.c: some long warnings were being improperly truncated
++ (CVE-2011-3464, bug introduced in libpng-1.5.3beta05).
++
++Version 1.6.0beta06 [January 24, 2012]
++ Added palette support to the simplified APIs. This commit
++ changes some of the macro definitions in png.h, app code
++ may need corresponding changes.
++ Increased the formatted warning buffer to 192 bytes.
++ Added color-map support to simplified API. This is an initial version for
++ review; the documentation has not yet been updated.
++ Fixed Min/GW uninstall to remove libpng.dll.a
++
++Version 1.6.0beta07 [January 28, 2012]
++ Eliminated Intel icc/icl compiler warnings. The Intel (GCC derived)
++ compiler issues slightly different warnings from those issued by the
++ current vesions of GCC. This eliminates those warnings by
++ adding/removing casts and small code rewrites.
++ Updated configure.ac from autoupdate: added --enable-werror option.
++ Also some layout regularization and removal of introduced tab characters
++ (replaced with 3-character indentation). Obsolete macros identified by
++ autoupdate have been removed; the replacements are all in 2.59 so
++ the pre-req hasn't been changed. --enable-werror checks for support
++ for -Werror (or the given argument) in the compiler. This mimics the
++ gcc configure option by allowing -Werror to be turned on safely; without
++ the option the tests written in configure itself fail compilation because
++ they cause compiler warnings.
++ Rewrote autogen.sh to run autoreconf instead of running tools one-by-one.
++ Conditionalize the install rules for MINGW and CYGWIN in CMakeLists.txt and
++ set CMAKE_LIBRARY_OUTPUT_DIRECTORY to "lib" on all platforms (C. Yapp).
++ Freeze libtool files in the 'scripts' directory. This version of autogen.sh
++ attempts to dissuade people from running it when it is not, or should not,
++ be necessary. In fact, autogen.sh does not work when run in a libpng
++ directory extracted from a tar distribution anymore. You must run it in
++ a GIT clone instead.
++ Added two images to contrib/pngsuite (1-bit and 2-bit transparent grayscale),
++ and renamed three whose names were inconsistent with those in
++ pngsuite/README.txt.
++
++Version 1.6.0beta08 [February 1, 2012]
++ Fixed Image::colormap misalignment in pngstest.c
++ Check libtool/libtoolize version number (2.4.2) in configure.ac
++ Divide test-pngstest.sh into separate pngstest runs for basic and
++ transparent images.
++ Moved automake options to AM_INIT_AUTOMAKE in configure.ac
++ Added color-tests, silent-rules (Not yet implemented in Makefile.am) and
++ version checking to configure.ac
++ Improved pngstest speed by not doing redundant tests and add const to
++ the background parameter of png_image_finish_read. The --background
++ option is now done automagically only when required, so that commandline
++ option no longer exists.
++ Cleaned up pngpriv.h to consistently declare all functions and data.
++ Also eliminated PNG_CONST_DATA, which is apparently not needed but we
++ can't be sure until it is gone.
++ Added symbol prefixing that allows all the libpng external symbols
++ to be prefixed (suggested by Reuben Hawkins).
++ Updated "ftbb*.png" list in the owatcom and vstudio projects.
++ Fixed 'prefix' builds on clean systems. The generation of pngprefix.h
++ should not require itself.
++ Updated INSTALL to explain that autogen.sh must be run in a GIT clone,
++ not in a libpng directory extracted from a tar distribution.
++
++Version 1.6.0beta09 [February 1, 2012]
++ Reverted the prebuilt configure files to libpng-1.6.0beta05 condition.
++
++Version 1.6.0beta10 [February 3, 2012]
++ Added Z_SOLO for zlib-1.2.6+ and correct pngstest tests
++ Updated list of test images in CMakeLists.txt
++ Updated the prebuilt configure files to current condition.
++ Revised INSTALL information about autogen.sh; it works in tar distributions.
++
++Version 1.6.0beta11 [February 16, 2012]
++ Fix character count in pngstest command in projects/owatcom/pngstest.tgt
++ Revised test-pngstest.sh to report PASS/FAIL for each image.
++ Updated documentation about the simplified API.
++ Corrected estimate of error in libpng png_set_rgb_to_gray API. The API is
++ extremely inaccurate for sRGB conversions because it uses an 8-bit
++ intermediate linear value and it does not use the sRGB transform, so it
++ suffers from the known instability in gamma transforms for values close
++ to 0 (see Poynton). The net result is that the calculation has a maximum
++ error of 14.99/255; 0.5/255^(1/2.2). pngstest now uses 15 for the
++ permitted 8-bit error. This may still not be enough because of arithmetic
++ error.
++ Removed some unused arrays (with #ifdef) from png_read_push_finish_row().
++ Fixed a memory overwrite bug in simplified read of RGB PNG with
++ non-linear gamma Also bugs in the error checking in pngread.c and changed
++ quite a lot of the checks in pngstest.c to be correct; either correctly
++ written or not over-optimistic. The pngstest changes are insufficient to
++ allow all possible RGB transforms to be passed; pngstest cmppixel needs
++ to be rewritten to make it clearer which errors it allows and then changed
++ to permit known inaccuracies.
++ Removed tests for no-longer-used *_EMPTY_PLTE_SUPPORTED from pngstruct.h
++ Fixed fixed/float API export conditionals. 1) If FIXED_POINT or
++ FLOATING_POINT options were switched off, png.h ended up with lone ';'
++ characters. This is not valid ANSI-C outside a function. The ';'
++ characters have been moved inside the definition of PNG_FP_EXPORT and
++ PNG_FIXED_EXPORT. 2) If either option was switched off, the declaration
++ of the corresponding functions were completely omitted, even though some
++ of them are still used internally. The result is still valid, but
++ produces warnings from gcc with some warning options (including -Wall). The
++ fix is to cause png.h to declare the functions with PNG_INTERNAL_FUNCTION
++ when png.h is included from pngpriv.h.
++ Check for invalid palette index while reading paletted PNG. When one is
++ found, issue a warning and increase png_ptr->num_palette accordingly.
++ Apps are responsible for checking to see if that happened.
++
++Version 1.6.0beta12 [February 18, 2012]
++ Do not increase num_palette on invalid_index.
++ Relocated check for invalid palette index to pngrtran.c, after unpacking
++ the sub-8-bit pixels.
++ Fixed CVE-2011-3026 buffer overrun bug. This bug was introduced when
++ iCCP chunk support was added at libpng-1.0.6. Deal more correctly with the
++ test on iCCP chunk length. Also removed spurious casts that may hide
++ problems on 16-bit systems.
++
++Version 1.6.0beta13 [February 24, 2012]
++ Eliminated redundant png_push_read_tEXt|zTXt|iTXt|unknown code from
++ pngpread.c and use the sequential png_handle_tEXt, etc., in pngrutil.c;
++ now that png_ptr->buffer is inaccessible to applications, the special
++ handling is no longer useful.
++ Added PNG_SAFE_LIMITS feature to pnglibconf.dfa, pngpriv.h, and new
++ pngusr.dfa to reset the user limits to safe ones if PNG_SAFE_LIMITS is
++ defined. To enable, use "CPPFLAGS=-DPNG_SAFE_LIMITS_SUPPORTED=1" on the
++ configure command or put #define PNG_SAFE_LIMITS_SUPPORTED in
++ pnglibconf.h.prebuilt and pnglibconf.h.
++
++Version 1.6.0beta14 [February 27, 2012]
++ Added information about the new limits in the manual.
++ Updated Makefile.in
++
++Version 1.6.0beta15 [March 2, 2012]
++ Removed unused "current_text" members of png_struct and the png_free()
++ of png_ptr->current_text from pngread.c
++ Rewrote pngstest.c for substantial speed improvement.
++ Fixed transparent pixel and 16-bit rgb tests in pngstest and removed a
++ spurious check in pngwrite.c
++ Added PNG_IMAGE_FLAG_FAST for the benefit of applications that store
++ intermediate files, or intermediate in-memory data, while processing
++ image data with the simplified API. The option makes the files larger
++ but faster to write and read. pngstest now uses this by default; this
++ can be disabled with the --slow option.
++ Improved pngstest fine tuning of error numbers, new test file generator.
++ The generator generates images that test the full range of sample values,
++ allow the error numbers in pngstest to be tuned and checked. makepng
++ also allows generation of images with extra chunks, although this is
++ still work-in-progress.
++ Added check for invalid palette index while reading.
++ Fixed some bugs in ICC profile writing. The code should now accept
++ all potentially valid ICC profiles and reject obviously invalid ones.
++ It now uses png_error() to do so rather than casually writing a PNG
++ without the necessary color data.
++ Removed whitespace from the end of lines in all source files and scripts.
++
++Version 1.6.0beta16 [March 6, 2012]
++ Relocated palette-index checking function from pngrutil.c to pngtrans.c
++ Added palette-index checking while writing.
++ Changed png_inflate() and calling routines to avoid overflow problems.
++ This is an intermediate check-in that solves the immediate problems and
++ introduces one performance improvement (avoiding a copy via png_ptr->zbuf.)
++ Further changes will be made to make ICC profile handling more secure.
++ Fixed build warnings (MSVC, GCC, GCC v3). Cygwin GCC with default options
++ declares 'index' as a global, causing a warning if it is used as a local
++ variable. GCC 64-bit warns about assigning a (size_t) (unsigned 64-bit)
++ to an (int) (signed 32-bit). MSVC, however, warns about using the
++ unary '-' operator on an unsigned value (even though it is well defined
++ by ANSI-C to be ~x+1). The padding calculation was changed to use a
++ different method. Removed the tests on png_ptr->pass.
++ Added contrib/libtests/tarith.c to test internal arithmetic functions from
++ png.c. This is a libpng maintainer program used to validate changes to the
++ internal arithmetic functions.
++ Made read 'inflate' handling like write 'deflate' handling. The read
++ code now claims and releases png_ptr->zstream, like the write code.
++ The bug whereby the progressive reader failed to release the zstream
++ is now fixed, all initialization is delayed, and the code checks for
++ changed parameters on deflate rather than always calling
++ deflatedEnd/deflateInit.
++ Validate the zTXt strings in pngvalid.
++ Added code to validate the windowBits value passed to deflateInit2().
++ If the call to deflateInit2() is wrong a png_warning will be issued
++ (in fact this is harmless, but the PNG data produced may be sub-optimal).
++
++Version 1.6.0beta17 [March 10, 2012]
++ Fixed PNG_LIBPNG_BUILD_BASE_TYPE definition.
++ Reject all iCCP chunks after the first, even if the first one is invalid.
++ Deflate/inflate was reworked to move common zlib calls into single
++ functions [rw]util.c. A new shared keyword check routine was also added
++ and the 'zbuf' is no longer allocated on progressive read. It is now
++ possible to call png_inflate() incrementally. A warning is no longer
++ issued if the language tag or translated keyword in the iTXt chunk
++ has zero length.
++ If benign errors are disabled use maximum window on ancilliary inflate.
++ This works round a bug introduced in 1.5.4 where compressed ancillary
++ chunks could end up with a too-small windowBits value in the deflate
++ header.
++
++Version 1.6.0beta18 [March 16, 2012]
++ Issue a png_benign_error() instead of png_warning() about bad palette index.
++ In pngtest, treat benign errors as errors if "-strict" is present.
++ Fixed an off-by-one error in the palette index checking function.
++ Fixed a compiler warning under Cygwin (Windows-7, 32-bit system)
++ Revised example.c to put text strings in a temporary character array
++ instead of directly assigning string constants to png_textp members.
++ This avoids compiler warnings when -Wwrite-strings is enabled.
++ Added output flushing to aid debugging under Visual Studio. Unfortunately
++ this is necessary because the VS2010 output window otherwise simply loses
++ the error messages on error (they weren't flushed to the window before
++ the process exited, apparently!)
++ Added configuration support for benign errors and changed the read
++ default. Also changed some warnings in the iCCP and sRGB handling
++ from to benign errors. Configuration now makes read benign
++ errors warnings and write benign errors to errors by default (thus
++ changing the behavior on read). The simplified API always forces
++ read benign errors to warnings (regardless of the system default, unless
++ this is disabled in which case the simplified API can't be built.)
++
++Version 1.6.0beta19 [March 18, 2012]
++ Work around for duplicate row start calls; added warning messages.
++ This turns on PNG_FLAG_DETECT_UNINITIALIZED to detect app code that
++ fails to call one of the 'start' routines (not enabled in libpng-1.5
++ because it is technically an API change, since it did normally work
++ before.) It also makes duplicate calls to png_read_start_row (an
++ internal function called at the start of the image read) benign, as
++ they were before changes to use png_inflate_claim. Somehow webkit is
++ causing this to happen; this is probably a mis-feature in the zlib
++ changes so this commit is only a work-round.
++ Removed erroneous setting of DETECT_UNINITIALIZED and added more
++ checks. The code now does a png_error if an attempt is made to do the
++ row initialization twice; this is an application error and it has
++ serious consequences because the transform data in png_struct is
++ changed by each call.
++ Added application error reporting and added chunk names to read
++ benign errors; also added --strict to pngstest - not enabled
++ yet because a warning is produced.
++ Avoid the double gamma correction warning in the simplified API.
++ This allows the --strict option to pass in the pngstest checks
++
++Version 1.6.0beta20 [March 29, 2012]
++ Changed chunk handler warnings into benign errors, incrementally load iCCP
++ Added checksum-icc.c to contrib/tools
++ Prevent PNG_EXPAND+PNG_SHIFT doing the shift twice.
++ Recognize known sRGB ICC profiles while reading; prefer writing the
++ iCCP profile over writing the sRGB chunk, controlled by the
++ PNG_sRGB_PROFILE_CHECKS option.
++ Revised png_set_text_2() to avoid potential memory corruption (fixes
++ CVE-2011-3048, also known as CVE-2012-3425).
++
++Version 1.6.0beta21 [April 27, 2012]
++ Revised scripts/makefile.darwin: use system zlib; remove quotes around
++ architecture list; add missing ppc architecture; add architecture options
++ to shared library link; don't try to create a shared lib based on missing
++ RELEASE variable.
++ Enable png_set_check_for_invalid_index() for both read and write.
++ Removed #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED in pngpriv.h around
++ declaration of png_handle_unknown().
++ Added -lssp_nonshared in a comment in scripts/makefile.freebsd
++ and changed deprecated NOOBJ and NOPROFILE to NO_OBJ and NO_PROFILE.
++
++Version 1.6.0beta22 [May 23, 2012]
++ Removed need for -Wno-cast-align with clang. clang correctly warns on
++ alignment increasing pointer casts when -Wcast-align is passed. This
++ fixes the cases that clang warns about either by eliminating the
++ casts from png_bytep to png_uint_16p (pngread.c), or, for pngrutil.c
++ where the cast is previously verified or pngstest.c where it is OK, by
++ introducing new png_aligncast macros to do the cast in a way that clang
++ accepts.
++
++Version 1.6.0beta23 [June 6, 2012]
++ Revised CMakeLists.txt to not attempt to make a symlink under mingw.
++ Made fixes for new optimization warnings from gcc 4.7.0. The compiler
++ performs an optimization which is safe; however it then warns about it.
++ Changing the type of 'palette_number' in pngvalid.c removes the warning.
++ Do not depend upon a GCC feature macro being available for use in generating
++ the linker mapfile symbol prefix.
++ Improved performance of new do_check_palette_indexes() function (only
++ update the value when it actually increases, move test for whether
++ the check is wanted out of the function.
++
++Version 1.6.0beta24 [June 7, 2012]
++ Don't check palette indexes if num_palette is 0 (as it can be in MNG files).
++
++Version 1.6.0beta25 [June 16, 2012]
++ Revised png_set_keep_unknown_chunks() so num_chunks < 0 means ignore all
++ unknown chunks and all known chunks except for IHDR, PLTE, tRNS, IDAT,
++ and IEND. Previously it only meant ignore all unknown chunks, the
++ same as num_chunks == 0. Revised png_image_skip_unused_chunks() to
++ provide a list of chunks to be processed instead of a list of chunks to
++ ignore. Revised contrib/gregbook/readpng2.c accordingly.
++
++Version 1.6.0beta26 [July 10, 2012]
++ Removed scripts/makefile.cegcc from the *.zip and *.7z distributions; it
++ depends on configure, which is not included in those archives.
++ Moved scripts/chkfmt to contrib/tools.
++ Changed "a+w" to "u+w" in Makefile.in to fix CVE-2012-3386.
++
++Version 1.6.0beta27 [August 11, 2012]
++ Do not compile PNG_DEPRECATED, PNG_ALLOC and PNG_PRIVATE when __GNUC__ < 3.
++ Do not use __restrict when GNUC is <= 3.1
++ Removed references to png_zalloc() and png_zfree() from the manual.
++ Fixed configurations where floating point is completely disabled. Because
++ of the changes to support symbol prefixing PNG_INTERNAL_FUNCTION declares
++ floating point APIs during libpng builds even if they are completely
++ disabled. This requires the png floating point types (png_double*) to be
++ declared even though the functions are never actually defined. This
++ change provides a dummy definition so that the declarations work, yet any
++ implementation will fail to compile because of an incomplete type.
++ Re-eliminated the use of strcpy() in pngtest.c. An unncessary use of
++ strcpy() was accidentally re-introduced in libpng16; this change replaces
++ it with strncpy().
++ Eliminated use of png_sizeof(); use sizeof() instead.
++ Use a consistent style for (sizeof type) and (sizeof (array))
++ Cleanup of png_set_filler(). This function does very different things on
++ read and write. In libpng 1.6 the two cases can be distinguished and
++ considerable code cleanup, and extra error checking, is possible. This
++ makes calls on the write side that have no effect be ignored with a
++ png_app_error(), which can be disabled in the app using
++ png_set_benign_errors(), and removes the spurious use of usr_channels
++ on the read side.
++ Insist on autotools 1.12.1 for git builds because there are security issues
++ with 1.12 and insisting on anything less would allow 1.12 to be used.
++ Removed info_ptr->signature[8] from WRITE-only builds.
++ Add some conditions for compiling png_fixed(). This is a small function
++ but it requires "-lm" on some platforms.
++ Cause pngtest --strict to fail on any warning from libpng (not just errors)
++ and cause it not to fail at the comparison step if libpng lacks support
++ for writing chunks that it reads from the input (currently only implemented
++ for compressed text chunks).
++ Make all three "make check" test programs work without READ or WRITE support.
++ Now "make check" will succeed even if libpng is compiled with -DPNG_NO_READ
++ or -DPNG_NO_WRITE. The tests performed are reduced, but the basic reading
++ and writing of a PNG file is always tested by one or more of the tests.
++ Consistently use strlen(), memset(), memcpy(), and memcmp() instead of the
++ png_strlen(), png_memset(), png_memcpy(), and png_memcmp() macros.
++ Removed the png_sizeof(), png_strlen(), png_memset(), png_memcpy(), and
++ png_memcmp() macros.
++ Work around gcc 3.x and Microsoft Visual Studio 2010 complaints. Both object
++ to the split initialization of num_chunks.
++
++Version 1.6.0beta28 [August 29, 2012]
++ Unknown handling fixes and clean up. This adds more correct option
++ control of the unknown handling, corrects the pre-existing bug where
++ the per-chunk 'keep' setting is ignored and makes it possible to skip
++ IDAT chunks in the sequential reader (broken in earlier 1.6 versions).
++ There is a new test program, test-unknown.c, which is a work in progress
++ (not currently part of the test suite). Comments in the header files now
++ explain how the unknown handling works.
++ Allow fine grain control of unknown chunk APIs. This change allows
++ png_set_keep_unknown_chunks() to be turned off if not required and causes
++ both read and write to behave appropriately (on read this is only possible
++ if the user callback is used to handle unknown chunks). The change
++ also removes the support for storing unknown chunks in the info_struct
++ if the only unknown handling enabled is via the callback, allowing libpng
++ to be configured with callback reading and none of the unnecessary code.
++ Corrected fix for unknown handling in pngtest. This reinstates the
++ libpng handling of unknown chunks other than vpAg and sTER (including
++ unsafe-to-copy chunks which were dropped before) and eliminates the
++ repositioning of vpAg and sTER in pngtest.png by changing pngtest.png
++ (so the chunks are where libpng would put them).
++ Added "tunknown" test and corrected a logic error in png_handle_unknown()
++ when SAVE support is absent. Moved the shell test scripts for
++ contrib/libtests from the libpng top directory to contrib/libtests.
++ png_handle_unknown() must always read or skip the chunk, if
++ SAVE_UNKNOWN_CHUNKS is turned off *and* the application does not set
++ a user callback an unknown chunk will not be read, leading to a read
++ error, which was revealed by the "tunknown" test.
++ Cleaned up and corrected ICC profile handling.
++ contrib/libtests/makepng: corrected 'rgb' and 'gray' cases. profile_error
++ messages could be truncated; made a correct buffer size calculation and
++ adjusted pngerror.c appropriately. png_icc_check_* checking improved;
++ changed the functions to receive the correct color type of the PNG on read
++ or write and check that it matches the color space of the profile (despite
++ what the comments said before, there is danger in assuming the app will
++ cope correctly with an RGB profile on a grayscale image and, since it
++ violates the PNG spec, allowing it is certain to produce inconsistent
++ app behavior and might even cause app crashes.) Check that profiles
++ contain the tags needed to process the PNG (tags all required by the ICC
++ spec). Removed unused PNG_STATIC from pngpriv.h.
++
++Version 1.6.0beta29 [September 4, 2012]
++ Fixed the simplified API example programs to add the *colormap parameter
++ to several of he API and improved the error message if the version field
++ is not set.
++ Added contrib/examples/* to the *.zip and *.7z distributions.
++ Updated simplified API synopses and description of the png_image structure
++ in the manual.
++ Made makepng and pngtest produce identical PNGs, add "--relaxed" option
++ to pngtest. The "--relaxed" option turns off the benign errors that are
++ enabled by default in pre-RC builds. makepng can now write ICC profiles
++ where the length has not been extended to a multiple of 4, and pngtest
++ now intercepts all libpng errors, allowing the previously-introduced
++ "--strict test" on no warnings to actually work.
++ Improved ICC profile handling including cHRM chunk generation and fixed
++ Cygwin+MSVC build errors. The ICC profile handling now includes more
++ checking. Several errors that caused rejection of the profile are now
++ handled with a warning in such a way that the invalid profiles will be
++ read by default in release (but not pre-RC) builds but will not be
++ written by default. The easy part of handling the cHRM chunk is written,
++ where the ICC profile contains the required data. The more difficult
++ 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()
++ (CVE-2013-7353). Added overflow detection in png_set_sPLT() and
++ png_set_text_2() (CVE-2013-7354).
++
++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.
++
++Version 1.6.0rc04 [February 7, 2013]
++ Turn serial tests back on (recently turned off by autotools upgrade).
++
++Version 1.6.0rc05 [February 8, 2013]
++ Update manual about png_get_palette_max().
++
++Version 1.6.0rc06 [February 9, 2013]
++ Fixed missing dependency in --prefix builds The intermediate
++ internal 'prefix.h' file can only be generated correctly after
++ pnglibconf.h, however the dependency was not in Makefile.am. The
++ symptoms are unpredictable depending on the order make chooses to
++ build pngprefix.h and pnglibconf.h, often the error goes unnoticed
++ because there is a system pnglibconf.h to use instead.
++
++Version 1.6.0rc07 [February 10, 2013]
++ Enclosed the new png_get_palette_max in #ifdef PNG_GET_PALETTE_MAX_SUPPORTED
++ block, and revised pnglibconf.h and pnglibconf.h.prebuilt accordingly.
++
++Version 1.6.0rc08 [February 10, 2013]
++ Fix typo in png.h #ifdef
++
++Version 1.6.0 [February 14, 2013]
++ No changes.
++
++Version 1.6.1beta01 [February 16, 2013]
++ Made symbol prefixing work with the ARM neon optimizations. Also allow
++ pngpriv.h to be included for preprocessor definitions only, so it can
++ be used in non-C/C++ files. Back ported from libpng 1.7.
++ Made sRGB check numbers consistent.
++ Ported libpng 1.5 options.awk/dfn file handling to 1.6, fixed one bug.
++ Removed cc -E workround, corrected png_get_palette_max API Tested on
++ SUN OS cc 5.9, which demonstrates the tokenization problem previously
++ avoided by using /lib/cpp. Since all .dfn output is now protected in
++ double quotes unless it is to be macro substituted the fix should
++ work everywhere.
++ Enabled parallel tests - back ported from libpng-1.7.
++ scripts/pnglibconf.dfa formatting improvements back ported from libpng17.
++ Fixed a race condition in the creation of the build 'scripts' directory
++ while building with a parallel make.
++ Use approved/supported Android method to check for NEON, use Linux/POSIX
++ 1003.1 API to check /proc/self/auxv avoiding buffer allocation and other
++ library calls (ported from libpng15).
++
++Version 1.6.1beta02 [February 19, 2013]
++ Use parentheses more consistently in "#if defined(MACRO)" tests.
++ Folded long lines.
++ Reenabled code to allow zero length PLTE chunks for MNG.
++
++Version 1.6.1beta03 [February 22, 2013]
++ Fixed ALIGNED_MEMORY support.
++ Allow run-time ARM NEON checking to be disabled. A new configure option:
++ --enable-arm-neon=always will stop the run-time checks. New checks
++ within arm/arm_init.c will cause the code not to be compiled unless
++ __ARM_NEON__ is set. This should make it fail safe (if someone asks
++ for it on then the build will fail if it can't be done.)
++ Updated the INSTALL document.
++
++Version 1.6.1beta04 [February 27, 2013]
++ Revised INSTALL to recommend using CPPFLAGS instead of INCLUDES.
++ Revised scripts/makefile.freebsd to respect ZLIBLIB and ZLIBINC.
++ Revised scripts/dfn.awk to work with the buggy MSYS awk that has trouble
++ with CRLF line endings.
++
++Version 1.6.1beta05 [March 1, 2013]
++ Avoid a possible memory leak in contrib/gregbook/readpng.c
++
++Version 1.6.1beta06 [March 4, 2013]
++ Better documentation of unknown handling API interactions.
++ Corrected Android builds and corrected libpng.vers with symbol
++ prefixing. This adds an API to set optimization options externally,
++ providing an alternative and general solution for the non-portable
++ run-time tests used by the ARM Neon code. It also makes those tests
++ compile and link on Android.
++ The order of settings vs options in pnglibconf.h is reversed to allow
++ settings to depend on options and options can now set (or override) the
++ defaults for settings.
++
++Version 1.6.1beta07 [March 7, 2013]
++ Corrected simplified API default gamma for color-mapped output, added
++ a flag to change default. In 1.6.0 when the simplified API was used
++ to produce color-mapped output from an input image with no gamma
++ information the gamma assumed for the input could be different from
++ that assumed for non-color-mapped output. In particular 16-bit depth
++ input files were assumed to be sRGB encoded, whereas in the 'direct'
++ case they were assumed to have linear data. This was an error. The
++ fix makes the simplified API treat all input files the same way and
++ adds a new flag to the png_image::flags member to allow the
++ application/user to specify that 16-bit files contain sRGB data
++ rather than the default linear.
++ Fixed bugs in the pngpixel and makepng test programs.
++
++Version 1.6.1beta08 [March 7, 2013]
++ Fixed CMakelists.txt to allow building a single variant of the library
++ (Claudio Bley):
++ Introduced a PNG_LIB_TARGETS variable that lists all activated library
++ targets. It is an error if this variable ends up empty, ie. you have
++ to build at least one library variant.
++ Made the *_COPY targets only depend on library targets actually being build.
++ Use PNG_LIB_TARGETS to unify a code path.
++ Changed the CREATE_SYMLINK macro to expect the full path to a file as the
++ first argument. When symlinking the filename component of that path is
++ determined and used as the link target.
++ Use copy_if_different in the CREATE_SYMLINK macro.
++
++Version 1.6.1beta09 [March 13, 2013]
++ Eliminated two warnings from the Intel C compiler. The warnings are
++ technically valid, although a reasonable treatment of division would
++ show it to be incorrect.
++
++Version 1.6.1rc01 [March 21, 2013]
++ No changes.
++
++Version 1.6.1 [March 28, 2013]
++ No changes.
++
++Version 1.6.2beta01 [April 14, 2013]
++ Updated documentation of 1.5.x to 1.6.x changes in iCCP chunk handling.
++ Fixed incorrect warning of excess deflate data. End condition - the
++ warning would be produced if the end of the deflate stream wasn't read
++ in the last row. The warning is harmless.
++ Corrected the test on user transform changes on read. It was in the
++ png_set of the transform function, but that doesn't matter unless the
++ transform function changes the rowbuf size, and that is only valid if
++ transform_info is called.
++ Corrected a misplaced closing bracket in contrib/libtests/pngvalid.c
++ (Flavio Medeiros).
++ Corrected length written to uncompressed iTXt chunks (Samuli Suominen).
++ Bug was introduced in libpng-1.6.0.
++
++Version 1.6.2rc01 [April 18, 2013]
++ Added contrib/tools/fixitxt.c, to repair the erroneous iTXt chunk length
++ written by libpng-1.6.0 and 1.6.1.
++ Disallow storing sRGB information when the sRGB is not supported.
++
++Version 1.6.2rc02 [April 18, 2013]
++ Merge pngtest.c with libpng-1.7.0
++
++Version 1.6.2rc03 [April 22, 2013]
++ Trivial spelling cleanup.
++
++Version 1.6.2rc04 and 1.6.2rc05 [omitted]
++
++Version 1.6.2rc06 [April 24, 2013]
++ Reverted to version 1.6.2rc03. Recent changes to arm/neon support
++ have been ported to libpng-1.7.0beta09 and will reappear in version
++ 1.6.3beta01.
++
++Version 1.6.2 [April 25, 2013]
++ No changes.
++
++Version 1.6.3beta01 [April 25, 2013]
++ Revised stack marking in arm/filter_neon.S and configure.ac.
++ Ensure that NEON filter stuff is completely disabled when switched 'off'.
++ Previously the ARM NEON specific files were still built if the option
++ was switched 'off' as opposed to being explicitly disabled.
++
++Version 1.6.3beta02 [April 26, 2013]
++ Test for 'arm*' not just 'arm' in the host_cpu configure variable.
++ Rebuilt the configure scripts.
++
++Version 1.6.3beta03 [April 30, 2013]
++ Expanded manual paragraph about writing private chunks, particularly
++ the need to call png_set_keep_unknown_chunks() when writing them.
++ Avoid dereferencing NULL pointer possibly returned from
++ png_create_write_struct() (Andrew Church).
++
++Version 1.6.3beta05 [May 9, 2013]
++ Calculate our own zlib windowBits when decoding rather than trusting the
++ CMF bytes in the PNG datastream.
++ Added an option to force maximum window size for inflating, which was
++ the behavior of libpng15 and earlier.
++ Added png-fix-itxt and png-fix-too-far-back to the built programs and
++ removed warnings from the source code and timepng that are revealed as
++ a result.
++ Detect wrong libpng versions linked to png-fix-too-far-back, which currently
++ only works with libpng versions that can be made to reliably fail when
++ the deflate data contains an out-of-window reference. This means only
++ 1.6 and later.
++ Fixed gnu issues: g++ needs a static_cast, gcc 4.4.7 has a broken warning
++ message which it is easier to work round than ignore.
++ Updated contrib/pngminus/pnm2png.c (Paul Stewart):
++ Check for EOF
++ Ignore "#" delimited comments in input file to pnm2png.c.
++ Fixed whitespace handling
++ Added a call to png_set_packing()
++ Initialize dimension values so if sscanf fails at least we have known
++ invalid values.
++ Attempt to detect configuration issues with png-fix-too-far-back, which
++ requires both the correct libpng and the correct zlib to function
++ correctly.
++ Check ZLIB_VERNUM for mismatches, enclose #error in quotes
++ Added information in the documentation about problems with and fixes for
++ the bad CRC and bad iTXt chunk situations.
++
++Version 1.6.3beta06 [May 12, 2013]
++ Allow contrib/pngminus/pnm2png.c to compile without WRITE_INVERT and
++ WRITE_PACK supported (writes error message that it can't read P1 or
++ P4 PBM files).
++ Improved png-fix-too-far-back usage message, added --suffix option.
++ Revised contrib/pngminim/*/makefile to generate pnglibconf.h with the
++ right zlib header files.
++ Separated CPPFLAGS and CFLAGS in contrib/pngminim/*/makefile
++
++Version 1.6.3beta07 [June 8, 2013]
++ Removed a redundant test in png_set_IHDR().
++ Added set(CMAKE_CONFIGURATION_TYPES ...) to CMakeLists.txt (Andrew Hundt)
++ Deleted set(CMAKE_BUILD_TYPE) block from CMakeLists.txt
++ Enclose the prototypes for the simplified write API in
++ #ifdef PNG_STDIO_SUPPORTED/#endif
++ Make ARM NEON support work at compile time (not just configure time).
++ This moves the test on __ARM_NEON__ into pngconf.h to avoid issues when
++ using a compiler that compiles for multiple architectures at one time.
++ Removed PNG_FILTER_OPTIMIZATIONS and PNG_ARM_NEON_SUPPORTED from
++ pnglibconf.h, allowing more of the decisions to be made internally
++ (pngpriv.h) during the compile. Without this, symbol prefixing is broken
++ under certain circumstances on ARM platforms. Now only the API parts of
++ the optimizations ('check' vs 'api') are exposed in the public header files
++ except that the new setting PNG_ARM_NEON_OPT documents how libpng makes the
++ decision about whether or not to use the optimizations.
++ Protect symbol prefixing against CC/CPPFLAGS/CFLAGS useage.
++ Previous iOS/Xcode fixes for the ARM NEON optimizations moved the test
++ on __ARM_NEON__ from configure time to compile time. This breaks symbol
++ prefixing because the definition of the special png_init_filter_functions
++ call was hidden at configure time if the relevant compiler arguments are
++ passed in CFLAGS as opposed to CC. This change attempts to avoid all
++ the confusion that would result by declaring the init function even when
++ it is not used, so that it will always get prefixed.
++
++Version 1.6.3beta08 [June 18, 2013]
++ Revised libpng.3 so that "doclifter" can process it.
++
++Version 1.6.3beta09 [June 27, 2013]
++ Revised example.c to illustrate use of PNG_DEFAULT_sRGB and PNG_GAMMA_MAC_18
++ as parameters for png_set_gamma(). These have been available since
++ libpng-1.5.4.
++ Renamed contrib/tools/png-fix-too-far-back.c to pngfix.c and revised it
++ to check all compressed chunks known to libpng.
++
++Version 1.6.3beta10 [July 5, 2013]
++ Updated documentation to show default behavior of benign errors correctly.
++ Only compile ARM code when PNG_READ_SUPPORTED is defined.
++ Fixed undefined behavior in contrib/tools/pngfix.c and added new strip
++ option. pngfix relied on undefined behavior and even a simple change from
++ gcc to g++ caused it to fail. The new strip option 'unsafe' has been
++ implemented and is the default if --max is given. Option names have
++ been clarified, with --strip=transform now stripping the bKGD chunk,
++ which was stripped previously with --strip=unused.
++ Added all documented chunk types to pngpriv.h
++ Unified pngfix.c source with libpng17.
++
++Version 1.6.3rc01 [July 11, 2013]
++ No changes.
++
++Version 1.6.3 [July 18, 2013]
++ Revised manual about changes in iTXt chunk handling made in libpng-1.6.0.
++ Added "/* SAFE */" comments in pngrutil.c and pngrtran.c where warnings
++ may be erroneously issued by code-checking applications.
++
++Version 1.6.4beta01 [August 21, 2013]
++ Added information about png_set_options() to the manual.
++ Delay calling png_init_filter_functions() until a row with nonzero filter
++ is found.
++
++Version 1.6.4beta02 [August 30, 2013]
++ Fixed inconsistent conditional compilation of png_chunk_unknown_handling()
++ prototype, definition, and usage. Made it depend on
++ PNG_HANDLE_AS_UNKNOWN_SUPPORTED everywhere.
++
++Version 1.6.4rc01 [September 5, 2013]
++ No changes.
++
++Version 1.6.4 [September 12, 2013]
++ No changes.
++
++Version 1.6.5 [September 14, 2013]
++ Removed two stray lines of code from arm/arm_init.c.
++
++Version 1.6.6 [September 16, 2013]
++ Removed two stray lines of code from arm/arm_init.c, again.
++
++Version 1.6.7beta01 [September 30, 2013]
++ Revised unknown chunk code to correct several bugs in the NO_SAVE_/NO_WRITE
++ combination
++ Allow HANDLE_AS_UNKNOWN to work when other options are configured off. Also
++ fixed the pngminim makefiles to work when $(MAKEFLAGS) contains stuff
++ which terminates the make options (as by default in recent versions of
++ Gentoo).
++ Avoid up-cast warnings in pngvalid.c. On ARM the alignment requirements of
++ png_modifier are greater than that of png_store and as a consequence
++ compilation of pngvalid.c results in a warning about increased alignment
++ requirements because of the bare cast to (png_modifier*). The code is safe,
++ because the pointer is known to point to a stack allocated png_modifier,
++ but this change avoids the warning.
++ Fixed default behavior of ARM_NEON_API. If the ARM NEON API option was
++ compiled without the CHECK option it defaulted to on, not off.
++ Check user callback behavior in pngunknown.c. Previous versions compiled
++ if SAVE_UNKNOWN was not available but did nothing since the callback
++ was never implemented.
++ Merged pngunknown.c with 1.7 version and back ported 1.7 improvements/fixes
++
++Version 1.6.7beta02 [October 12, 2013]
++ Made changes for compatibility with automake 1.14:
++ 1) Added the 'compile' program to the list of programs that must be cleaned
++ in autogen.sh
++ 2) Added 'subdir-objects' which causes .c files in sub-directories to be
++ compiled such that the corresponding .o files are also in the
++ sub-directory. This is because automake 1.14 warns that the
++ current behavior of compiling to the top level directory may be removed
++ in the future.
++ 3) Updated dependencies on pnglibconf.h to match the new .o locations and
++ added all the files in contrib/libtests and contrib/tools that depend
++ on pnglibconf.h
++ 4) Added 'BUILD_SOURCES = pnglibconf.h'; this is the automake recommended
++ way of handling the dependencies of sources that are machine generated;
++ unfortunately it only works if the user does 'make all' or 'make check',
++ so the dependencies (3) are still required.
++ Cleaned up (char*) casts of zlib messages. The latest version of the Intel C
++ compiler complains about casting a string literal as (char*), so copied the
++ treatment of z_const from the library code into pngfix.c
++ Simplified error message code in pngunknown. The simplification has the
++ useful side effect of avoiding a bogus warning generated by the latest
++ version of the Intel C compiler (it objects to
++ condition ? string-literal : string-literal).
++ Make autogen.sh work with automake 1.13 as well as 1.14. Do this by always
++ removing the 1.14 'compile' script but never checking for it.
++
++Version 1.6.7beta03 [October 19, 2013]
++ Added ARMv8 support (James Yu <james.yu at linaro.org>). Added file
++ arm/filter_neon_intrinsics.c; enable with -mfpu=neon.
++ Revised pngvalid to generate size images with as many filters as it can
++ manage, limited by the number of rows.
++ Cleaned up ARM NEON compilation handling. The tests are now in pngpriv.h
++ and detect the broken GCC compilers.
++
++Version 1.6.7beta04 [October 26, 2013]
++ Allow clang derived from older GCC versions to use ARM intrinsics. This
++ causes all clang builds that use -mfpu=neon to use the intrinsics code,
++ not the assembler code. This has only been tested on iOS 7. It may be
++ necessary to exclude some earlier clang versions but this seems unlikely.
++ Changed NEON implementation selection mechanism. This allows assembler
++ or intrinsics to be turned on at compile time during the build by defining
++ PNG_ARM_NEON_IMPLEMENTATION to the correct value (2 or 1). This macro
++ is undefined by default and the build type is selected in pngpriv.h.
++
++Version 1.6.7rc01 [November 2, 2013]
++ No changes.
++
++Version 1.6.7rc02 [November 7, 2013]
++ Fixed #include in filter_neon_intrinsics.c and ctype macros. The ctype char
++ checking macros take an unsigned char argument, not a signed char.
++
++Version 1.6.7 [November 14, 2013]
++ No changes.
++
++Version 1.6.8beta01 [November 24, 2013]
++ Moved prototype for png_handle_unknown() in pngpriv.h outside of
++ the #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED/#endif block.
++ Added "-Wall" to CFLAGS in contrib/pngminim/*/makefile
++ Conditionally compile some unused functions reported by -Wall in
++ pngminim.
++ Fixed 'minimal' builds. Various obviously useful minimal configurations
++ don't build because of missing contrib/libtests test programs and
++ overly complex dependencies in scripts/pnglibconf.dfa. This change
++ adds contrib/conftest/*.dfa files that can be used in automatic build
++ scripts to ensure that these configurations continue to build.
++ Enabled WRITE_INVERT and WRITE_PACK in contrib/pngminim/encoder.
++ Fixed pngvalid 'fail' function declaration on the Intel C Compiler.
++ This reverts to the previous 'static' implementation and works round
++ the 'unused static function' warning by using PNG_UNUSED().
++
++Version 1.6.8beta02 [November 30, 2013]
++ Removed or marked PNG_UNUSED some harmless "dead assignments" reported
++ by clang scan-build.
++ Changed tabs to 3 spaces in png_debug macros and changed '"%s"m'
++ to '"%s" m' to improve portability among compilers.
++ Changed png_free_default() to free() in pngtest.c
++
++Version 1.6.8rc01 [December 12, 2013]
++ Tidied up pngfix inits and fixed pngtest no-write builds.
++
++Version 1.6.8rc02 [December 14, 2013]
++ Handle zero-length PLTE chunk or NULL palette with png_error()
++ instead of png_chunk_report(), which by default issues a warning
++ rather than an error, leading to later reading from a NULL pointer
++ (png_ptr->palette) in png_do_expand_palette(). This is CVE-2013-6954
++ and VU#650142. Libpng-1.6.1 through 1.6.7 are vulnerable.
++ Libpng-1.6.0 and earlier do not have this bug.
++
++Version 1.6.8 [December 19, 2013]
++ No changes.
++
++Version 1.6.9beta01 [December 26, 2013]
++ Bookkeeping: Moved functions around (no changes). Moved transform
++ function definitions before the place where they are called so that
++ they can be made static. Move the intrapixel functions and the
++ grayscale palette builder out of the png?tran.c files. The latter
++ isn't a transform function and is no longer used internally, and the
++ former MNG specific functions are better placed in pngread/pngwrite.c
++ Made transform implementation functions static. This makes the internal
++ functions called by png_do_{read|write}_transformations static. On an
++ x86-64 DLL build (Gentoo Linux) this reduces the size of the text
++ segment of the DLL by 1208 bytes, about 0.6%. It also simplifies
++ maintenance by removing the declarations from pngpriv.h and allowing
++ easier changes to the internal interfaces.
++ Rebuilt configure scripts with automake-1.14.1 and autoconf-2.69
++ in the tar distributions.
++
++Version 1.6.9beta02 [January 1, 2014]
++ Added checks for libpng 1.5 to pngvalid.c. This supports the use of
++ this version of pngvalid in libpng 1.5
++ Merged with pngvalid.c from libpng-1.7 changes to create a single
++ pngvalid.c
++ Removed #error macro from contrib/tools/pngfix.c (Thomas Klausner).
++ Merged pngrio.c, pngtrans.c, pngwio.c, and pngerror.c with libpng-1.7.0
++ Merged libpng-1.7.0 changes to make no-interlace configurations work
++ with test programs.
++ Revised pngvalid.c to support libpng 1.5, which does not support the
++ PNG_MAXIMUM_INFLATE_WINDOW option, so #define it out when appropriate in
++ pngvalid.c
++ Allow unversioned links created on install to be disabled in configure.
++ In configure builds 'make install' changes/adds links like png.h
++ and libpng.a to point to the newly installed, versioned, files (e.g.
++ libpng17/png.h and libpng17.a). Three new configure options and some
++ rearrangement of Makefile.am allow creation of these links to be disabled.
++
++Version 1.6.9beta03 [January 10, 2014]
++ Removed potentially misleading warning from png_check_IHDR().
++
++Version 1.6.9beta04 [January 20, 2014]
++ Updated scripts/makefile.* to use CPPFLAGS (Cosmin).
++ Added clang attribute support (Cosmin).
++
++Version 1.6.9rc01 [January 28, 2014]
++ No changes.
++
++Version 1.6.9rc02 [January 30, 2014]
++ Quiet an uninitialized memory warning from VC2013 in png_get_png().
++
++Version 1.6.9 [February 6, 2014]
++
++Version 1.6.10beta01 [February 9, 2014]
++ Backported changes from libpng-1.7.0beta30 and beta31:
++ Fixed a large number of instances where PNGCBAPI was omitted from
++ function definitions.
++ Added pngimage test program for png_read_png() and png_write_png()
++ with two new test scripts.
++ Removed dependence on !PNG_READ_EXPAND_SUPPORTED for calling
++ png_set_packing() in png_read_png().
++ Fixed combination of ~alpha with shift. On read invert alpha, processing
++ occurred after shift processing, which causes the final values to be
++ outside the range that should be produced by the shift. Reversing the
++ order on read makes the two transforms work together correctly and mirrors
++ the order used on write.
++ Do not read invalid sBIT chunks. Previously libpng only checked sBIT
++ values on write, so a malicious PNG writer could therefore cause
++ the read code to return an invalid sBIT chunk, which might lead to
++ application errors or crashes. Such chunks are now skipped (with
++ chunk_benign_error).
++ Make png_read_png() and png_write_png() prototypes in png.h depend
++ upon PNG_READ_SUPPORTED and PNG_WRITE_SUPPORTED.
++ Support builds with unsupported PNG_TRANSFORM_* values. All of the
++ PNG_TRANSFORM_* values are always defined in png.h and, because they
++ are used for both read and write in some cases, it is not reliable
++ to #if out ones that are totally unsupported. This change adds error
++ detection in png_read_image() and png_write_image() to do a
++ png_app_error() if the app requests something that cannot be done
++ and it adds corresponding code to pngimage.c to handle such options
++ by not attempting to test them.
++
++Version 1.6.10beta02 [February 23, 2014]
++ Moved redefines of png_error(), png_warning(), png_chunk_error(),
++ and png_chunk_warning() from pngpriv.h to png.h to make them visible
++ to libpng-calling applications.
++ Moved OS dependent code from arm/arm_init.c, to allow the included
++ implementation of the ARM NEON discovery function to be set at
++ build-time and provide sample implementations from the current code in the
++ contrib/arm-neon subdirectory. The __linux__ code has also been changed to
++ compile and link on Android by using /proc/cpuinfo, and the old linux code
++ is in contrib/arm-neon/linux-auxv.c. The new code avoids POSIX and Linux
++ dependencies apart from opening /proc/cpuinfo and is C90 compliant.
++ Check for info_ptr == NULL early in png_read_end() so we don't need to
++ run all the png_handle_*() and depend on them to return if info_ptr == NULL.
++ This improves the performance of png_read_end(png_ptr, NULL) and makes
++ it more robust against future programming errors.
++ Check for __has_extension before using it in pngconf.h, to
++ support older Clang versions (Jeremy Sequoia).
++ Treat CRC error handling with png_set_crc_action(), instead of with
++ png_set_benign_errors(), which has been the case since libpng-1.6.0beta18.
++ Use a user warning handler in contrib/gregbook/readpng2.c instead of default,
++ so warnings will be put on stderr even if libpng has CONSOLE_IO disabled.
++ Added png_ptr->process_mode = PNG_READ_IDAT_MODE in png_push_read_chunk
++ after recognizing the IDAT chunk, which avoids an infinite loop while
++ reading a datastream whose first IDAT chunk is of zero-length.
++ This fixes CERT VU#684412 and CVE-2014-0333.
++ Don't recognize known sRGB profiles as sRGB if they have been hacked,
++ but don't reject them and don't issue a copyright violation warning.
++
++Version 1.6.10beta03 [February 25, 2014]
++ Moved some documentation from png.h to libpng.3 and libpng-manual.txt
++ Minor editing of contrib/arm-neon/README and contrib/examples/*.c
++
++Version 1.6.10rc01 [February 27, 2014]
++ Fixed typos in the manual and in scripts/pnglibconf.dfa (CFLAGS -> CPPFLAGS
++ and PNG_USR_CONFIG -> PNG_USER_CONFIG).
++
++Version 1.6.10rc02 [February 28, 2014]
++ Removed unreachable return statement after png_chunk_error()
++ in pngrutil.c
++
++Version 1.6.10rc03 [March 4, 2014]
++ Un-deprecated png_data_freer().
++
++Version 1.6.10 [March 6, 2014]
++ No changes.
++
++Version 1.6.11beta01 [March 17, 2014]
++ Use "if (value != 0)" instead of "if (value)" consistently.
++ Changed ZlibSrcDir from 1.2.5 to 1.2.8 in projects/vstudio.
++ Moved configuration information from the manual to the INSTALL file.
++
++Version 1.6.11beta02 [April 6, 2014]
++ Removed #if/#else/#endif from inside two pow() calls in pngvalid.c because
++ they were handled improperly by Portland Group's PGI-14.1 - PGI-14.3
++ when using its "__builtin_pow()" function.
++ Silence 'unused parameter' build warnings (Cosmin Truta).
++ $(CP) is now used alongside $(RM_F). Also, use 'copy' instead of 'cp'
++ where applicable, and applied other minor makefile changes (Cosmin).
++ Don't warn about invalid dimensions exceeding user limits (Cosmin).
++ Allow an easy replacement of the default pre-built configuration
++ header with a custom header, via the make PNGLIBCONF_H_PREBUILT
++ macro (Cosmin).
++
++Version 1.6.11beta03 [April 6, 2014]
++ Fixed a typo in pngrutil.c, introduced in libpng-1.5.6, that interferes
++ with "blocky" expansion of sub-8-bit interlaced PNG files (Eric Huss).
++ Optionally use __builtin_bswap16() in png_do_swap().
++
++Version 1.6.11beta04 [April 19, 2014]
++ Made progressive reading of interlaced images consistent with the
++ behavior of the sequential reader and consistent with the manual, by
++ moving some code out of the PNG_READ_INTERLACING_SUPPORTED blocks. The
++ row_callback now receives the proper pass number and unexpanded rows, when
++ png_combine_row() isn't built or used, and png_set_interlace_handling()
++ is not called.
++ Allow PNG_sRGB_PROFILE_CHECKING = (-1) to mean no sRGB profile checking.
++
++Version 1.6.11beta05 [April 26, 2014]
++ Do not reject ICC V2 profiles that lack padding (Kai-Uwe Behrmann).
++ Relocated closing bracket of the sRGB profile test loop to avoid getting
++ "Not recognizing known sRGB profile that has been edited" warning for
++ ICC V2 profiles that lack the MD5 signature in the profile header.
++
++Version 1.6.11beta06 [May 19, 2014]
++ Added PNG_SKIP_sRGB_CHECK_PROFILE choice for png_set_option().
++
++Version 1.6.11rc01 [May 27, 2014]
++ No changes.
++
++Version 1.6.11rc02 [June 3, 2014]
++ Test ZLIB_VERNUM instead of PNG_ZLIB_VERNUM in contrib/tools/pngfix.c
++
++Version 1.6.11 [June 5, 2014]
++ No changes.
++
++Version 1.6.12rc01 [June 6, 2014]
++ Relocated new code from 1.6.11beta06 in png.c to a point after the
++ declarations (Max Stepin).
++
++Version 1.6.12rc02 [June 7, 2014]
++ Changed file permissions of contrib/tools/intgamma.sh,
++ test-driver, and compile from 0644 to 0755 (Cosmin).
++
++Version 1.6.12rc03 [June 8, 2014]
++ Ensure "__has_attribute()" macro exists before trying to use it with
++ old clang compilers (MacPorts Ticket #43939).
++
++Version 1.6.12 [June 12, 2014]
++ No changes.
++
++Version 1.6.13beta01 [July 4, 2014]
++ Quieted -Wsign-compare and -Wclobber compiler warnings in
++ contrib/pngminus/*.c
++ Added "(void) png_ptr;" where needed in contrib/gregbook to quiet
++ compiler complaints about unused pointers.
++ Split a long output string in contrib/gregbook/rpng2-x.c.
++ Added "PNG_SET_OPTION" requirement for sRGB chunk support to pnglibconf.dfa,
++ Needed for write-only support (John Bowler).
++ Changed "if defined(__ARM_NEON__)" to
++ "if (defined(__ARM_NEON__) || defined(__ARM_NEON))" (James Wu).
++ Fixed clang no-warning builds: png_digit was defined but never used.
++
++Version 1.6.13beta02 [July 21, 2014]
++ Fixed an incorrect separator ("/" should be "\") in scripts/makefile.vcwin32
++ (bug report from Wolfgang S. Kechel). Bug was introduced in libpng-1.6.11.
++ Also fixed makefile.bc32, makefile.bor, makefile.msc, makefile.intel, and
++ makefile.tc3 similarly.
++
++Version 1.6.13beta03 [August 3, 2014]
++ Removed scripts/makefile.elf. It has not worked since libpng-1.5.0beta14
++ due to elimination of the PNG_FUNCTION_EXPORT and PNG_DATA_EXPORT
++ definitions from pngconf.h.
++ Ensure that CMakeLists.txt makes the target "lib" directory before making
++ symbolic link into it (SourceForge bug report #226 by Rolf Timmermans).
++
++Version 1.6.13beta04 [August 8, 2014]
++ Added opinion that the ECCN (Export Control Classification Number) for
++ libpng is EAR99 to the README file.
++ Eliminated use of "$<" in makefile explicit rules, when copying
++ $PNGLIBCONF_H_PREBUILT. This does not work on some versions of make;
++ bug introduced in libpng version 1.6.11.
++
++Version 1.6.13rc01 [August 14, 2014]
++ Made "ccopts" agree with "CFLAGS" in scripts/makefile.hp* and makefile.*sunu
++
++Version 1.6.13 [August 21, 2014]
++ No changes.
++
++Version 1.6.14beta01 [September 14, 2014]
++ Guard usage of png_ptr->options with #ifdef PNG_SET_OPTION_SUPPORTED.
++ Do not build contrib/tools/pngfix.c when PNG_SETJMP_NOT_SUPPORTED,
++ to allow "make" to complete without setjmp support (bug report by
++ Claudio Fontana)
++ Add "#include <setjmp.h>" to contrib/tools/pngfix.c (John Bowler)
++
++Version 1.6.14beta02 [September 18, 2014]
++ Use nanosleep() instead of usleep() in contrib/gregbook/rpng2-x.c
++ because usleep() is deprecated.
++ Define usleep() in contrib/gregbook/rpng2-x.c if not already defined
++ in unistd.h and nanosleep() is not available; fixes error introduced
++ in libpng-1.6.13.
++ Disable floating point exception handling in pngvalid.c when
++ PNG_FLOATING_ARITHMETIC is not supported (bug report by "zootus
++ at users.sourceforge.net").
++
++Version 1.6.14beta03 [September 19, 2014]
++ Define FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in pngvalid.c if not
++ already defined. Revert floating point exception handling in pngvalid.c
++ to version 1.6.14beta01 behavior.
++
++Version 1.6.14beta04 [September 27, 2014]
++ Fixed incorrect handling of the iTXt compression flag in pngrutil.c
++ (bug report by Shunsaku Hirata). Bug was introduced in libpng-1.6.0.
++
++Version 1.6.14beta05 [October 1, 2014]
++ Added "option READ_iCCP enables READ_COMPRESSED_TEXT" to pnglibconf.dfa
++
++Version 1.6.14beta06 [October 5, 2014]
++ Removed unused "text_len" parameter from private function png_write_zTXt().
++ Conditionally compile some code in png_deflate_claim(), when
++ PNG_WARNINGS_SUPPORTED and PNG_ERROR_TEXT_SUPPORTED are disabled.
++ Replaced repeated code in pngpread.c with PNG_PUSH_SAVE_BUFFER_IF_FULL.
++ Added "chunk iTXt enables TEXT" and "chunk zTXt enables TEXT"
++ to pnglibconf.dfa.
++ Removed "option READ_COMPRESSED_TEXT enables READ_TEXT" from pnglibconf.dfa,
++ to make it possible to configure a libpng that supports iCCP but not TEXT.
++
++Version 1.6.14beta07 [October 7, 2014]
++ Removed "option WRITE_COMPRESSED_TEXT enables WRITE_TEXT" from pnglibconf.dfa
++ Only mark text chunks as written after successfully writing them.
++
++Version 1.6.14rc01 [October 15, 2014]
++ Fixed some typos in comments.
++
++Version 1.6.14rc02 [October 17, 2014]
++ Changed png_convert_to_rfc_1123() to png_convert_to_rfc_1123_buffer()
++ in the manual, to reflect the change made in libpng-1.6.0.
++ Updated README file to explain that direct access to the png_struct
++ and info_struct members has not been permitted since libpng-1.5.0.
++
++Version 1.6.14 [October 23, 2014]
++ No changes.
++
++Version 1.6.15beta01 [October 29, 2014]
++ Changed "if (!x)" to "if (x == 0)" and "if (x)" to "if (x != 0)"
++ Simplified png_free_data().
++ Added missing "ptr = NULL" after some instances of png_free().
++
++Version 1.6.15beta02 [November 1, 2014]
++ Changed remaining "if (!x)" to "if (x == 0)" and "if (x)" to "if (x != 0)"
++
++Version 1.6.15beta03 [November 3, 2014]
++ Added PNG_USE_ARM_NEON configuration flag (Marcin Juszkiewicz).
++
++Version 1.6.15beta04 [November 4, 2014]
++ Removed new PNG_USE_ARM_NEON configuration flag and made a one-line
++ revision to configure.ac to support ARM on aarch64 instead (John Bowler).
++
++Version 1.6.15beta05 [November 5, 2014]
++ Use png_get_libpng_ver(NULL) instead of PNG_LIBPNG_VER_STRING in
++ example.c, pngtest.c, and applications in the contrib directory.
++ Avoid out-of-bounds memory access in png_user_version_check().
++ Simplified and future-proofed png_user_version_check().
++ Fixed GCC unsigned int->float warnings. Various versions of GCC
++ seem to generate warnings when an unsigned value is implicitly
++ converted to double. This is probably a GCC bug but this change
++ avoids the issue by explicitly converting to (int) where safe.
++ Free all allocated memory in pngimage. The file buffer cache was left
++ allocated at the end of the program, harmless but it causes memory
++ leak reports from clang.
++ Fixed array size calculations to avoid warnings. At various points
++ in the code the number of elements in an array is calculated using
++ sizeof. This generates a compile time constant of type (size_t) which
++ is then typically assigned to an (unsigned int) or (int). Some versions
++ of GCC on 64-bit systems warn about the apparent narrowing, even though
++ the same compiler does apparently generate the correct, in-range,
++ numeric constant. This adds appropriate, safe, casts to make the
++ warnings go away.
++
++Version 1.6.15beta06 [November 6, 2014]
++ Reverted use png_get_libpng_ver(NULL) instead of PNG_LIBPNG_VER_STRING
++ in the manual, example.c, pngtest.c, and applications in the contrib
++ directory. It was incorrect advice.
++
++Version 1.6.15beta07 [November 7, 2014]
++ Removed #ifdef PNG_16BIT_SUPPORTED/#endif around png_product2(); it is
++ needed by png_reciprocal2().
++ Added #ifdef PNG_16BIT_SUPPORTED/#endif around png_log16bit() and
++ png_do_swap().
++ Changed all "#endif /* PNG_FEATURE_SUPPORTED */" to "#endif /* FEATURE */"
++
++Version 1.6.15beta08 [November 8, 2014]
++ More housecleaning in *.h
++
++Version 1.6.15rc01 [November 13, 2014]
++
++Version 1.6.15rc02 [November 14, 2014]
++ The macros passed in the command line to Borland make were ignored if
++ similarly-named macros were already defined in makefiles. This behavior
++ is different from POSIX make and other make programs. Surround the
++ macro definitions with ifndef guards (Cosmin).
++
++Version 1.6.15rc03 [November 16, 2014]
++ Added "-D_CRT_SECURE_NO_WARNINGS" to CFLAGS in scripts/makefile.vcwin32.
++ Removed the obsolete $ARCH variable from scripts/makefile.darwin.
++
++Version 1.6.15 [November 20, 2014]
++ No changes.
++
++Version 1.6.16beta01 [December 14, 2014]
++ Added ".align 2" to arm/filter_neon.S to support old GAS assemblers that
++ don't do alignment correctly.
++ Revised Makefile.am and scripts/symbols.dfn to work with MinGW/MSYS
++ (Bob Friesenhahn).
++
++Version 1.6.16beta02 [December 15, 2014]
++ Revised Makefile.am and scripts/*.dfn again to work with MinGW/MSYS;
++ renamed scripts/*.dfn to scripts/*.c (John Bowler).
++
++Version 1.6.16beta03 [December 21, 2014]
++ Quiet a "comparison always true" warning in pngstest.c (John Bowler).
++
++Version 1.6.16rc01 [December 21, 2014]
++ Restored a test on width that was removed from png.c at libpng-1.6.9
++ (Bug report by Alex Eubanks).
++
++Version 1.6.16rc02 [December 21, 2014]
++ Undid the update to pngrutil.c in 1.6.16rc01.
++
++Version 1.6.16rc03 [December 21, 2014]
++ Fixed an overflow in png_combine_row with very wide interlaced images.
++
++Version 1.6.16 [December 22, 2014]
++ No changes.
+
+ Send comments/corrections/commendations to png-mng-implement at lists.sf.net
+ (subscription required; visit
+@@ -3540,5 +5156,3 @@
+ or to glennrp at users.sourceforge.net
+
+ Glenn R-P
+-*/ }
+-#endif
+--- ./jdk/src/share/native/sun/awt/libpng/LICENSE Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/LICENSE Thu Feb 05 13:00:26 2015 +0100
+@@ -10,8 +10,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+--- ./jdk/src/share/native/sun/awt/libpng/README Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/README Thu Feb 05 13:00:26 2015 +0100
+@@ -1,11 +1,11 @@
+-README for libpng version 1.5.4 - July 7, 2011 (shared library 15.0)
++README for libpng version 1.6.16 - December 22, 2014 (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.
+
+-Libpng comes in several distribution formats. Get libpng-*.tar.gz,
+-libpng-*.tar.xz or libpng-*.tar.bz2 if you want UNIX-style line endings
+-in the text files, or lpng*.zip if you want DOS-style line endings.
++Libpng comes in several distribution formats. Get libpng-*.tar.gz or
++libpng-*.tar.xz or if you want UNIX-style line endings in the text files,
++or lpng*.7z or lpng*.zip if you want DOS-style line endings.
+
+ Version 0.89 was the first official release of libpng. Don't let the
+ fact that it's the first release fool you. The libpng library has been in
+@@ -23,18 +23,25 @@
+ png_uint_32, which will affect shared-library applications that use
+ this function.
+
+-To avoid problems with changes to the internals of png_info_struct,
++To avoid problems with changes to the internals of png info_struct,
+ new APIs have been made available in 0.95 to avoid direct application
+ access to info_ptr. These functions are the png_set_<chunk> and
+ png_get_<chunk> functions. These functions should be used when
+ accessing/storing the info_struct data, rather than manipulating it
+ directly, to avoid such problems in the future.
+
+-It is important to note that the APIs do not make current programs
++It is important to note that the APIs did not make current programs
+ that access the info struct directly incompatible with the new
+-library. However, it is strongly suggested that new programs use
+-the new APIs (as shown in example.c and pngtest.c), and older programs
+-be converted to the new format, to facilitate upgrades in the future.
++library, through libpng-1.2.x. In libpng-1.4.x, which was meant to
++be a transitional release, members of the png_struct and the
++info_struct can still be accessed, but the compiler will issue a
++warning about deprecated usage. Since libpng-1.5.0, direct access
++to these structs is not allowed, and the definitions of the structs
++reside in private pngstruct.h and pnginfo.h header files that are not
++accessible to applications. It is strongly suggested that new
++programs use the new APIs (as shown in example.c and pngtest.c), and
++older programs be converted to the new format, to facilitate upgrades
++in the future.
+ ****
+
+ Additions since 0.90 include the ability to compile libpng as a
+@@ -77,17 +84,21 @@
+ You can use zlib as a drop-in replacement for fread() and fwrite() if
+ you are so inclined.
+
+-zlib should be available at the same place that libpng is, or at.
+-ftp://ftp.info-zip.org/pub/infozip/zlib
++zlib should be available at the same place that libpng is, or at zlib.net.
+
+ You may also want a copy of the PNG specification. It is available
+ as an RFC, a W3C Recommendation, and an ISO/IEC Standard. You can find
+ these at http://www.libpng.org/pub/png/documents/
+
+ This code is currently being archived at libpng.sf.net in the
+-[DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT)
+-at GO GRAPHSUP. If you can't find it in any of those places,
+-e-mail me, and I'll help you find it.
++[DOWNLOAD] area, and at ftp://ftp.simplesystems.org. If you can't find it
++in any of those places, e-mail me, and I'll help you find it.
++
++I am not a lawyer, but I believe that the Export Control Classification
++Number (ECCN) for libpng is EAR99, which means not subject to export
++controls or International Traffic in Arms Regulations (ITAR) because it
++is open source, publicly available software, that does not contain any
++encryption software. See the EAR, paragraphs 734.3(b)(3) and 734.7(b).
+
+ If you have any code changes, requests, problems, etc., please e-mail
+ them to me. Also, I'd appreciate any make files or project files,
+@@ -105,7 +116,7 @@
+ development group.
+
+ Send comments/corrections/commendations to png-mng-implement at
+-lists.sourceforge.net (subscription required; visit
++lists.sourceforge.net (subscription required; visit
+ https://lists.sourceforge.net/lists/listinfo/png-mng-implement
+ to subscribe) or to glennrp at users.sourceforge.net
+
+@@ -123,7 +134,7 @@
+ to others, if necessary.
+
+ Please do not send suggestions on how to change PNG. We have
+-been discussing PNG for sixteen years now, and it is official and
++been discussing PNG for nineteen years now, and it is official and
+ finished. If you have suggestions for libpng, however, I'll
+ gladly listen. Even if your suggestion is not used immediately,
+ it may be used later.
+@@ -167,23 +178,25 @@
+ pngwrite.c => High-level write functions
+ pngwtran.c => Write data transformations
+ pngwutil.c => Write utility functions
++ arm => Contains optimized code for the ARM platform
+ contrib => Contributions
++ examples => Example programs
+ gregbook => source code for PNG reading and writing, from
+ Greg Roelofs' "PNG: The Definitive Guide",
+ O'Reilly, 1999
+- msvctest => Builds and runs pngtest using a MSVC workspace
+- pngminus => Simple pnm2png and png2pnm programs
+- pngsuite => Test images
+- visupng => Contains a MSVC workspace for VisualPng
++ libtests => Test programs
++ pngminim => Minimal decoder, encoder, and progressive decoder
++ programs demonstrating use of pngusr.dfa
++ pngminus => Simple pnm2png and png2pnm programs
++ pngsuite => Test images
++ tools => Various tools
++ visupng => Contains a MSVC workspace for VisualPng
+ projects => Contains project files and workspaces for
+ building a DLL
+- cbuilder5 => Contains a Borland workspace for building
+- libpng and zlib
+- visualc6 => Contains a Microsoft Visual C++ (MSVC)
+- workspace for building libpng and zlib
++ owatcom => Contains a WATCOM project for building libpng
+ visualc71 => Contains a Microsoft Visual C++ (MSVC)
+ workspace for building libpng and zlib
+- xcode => Contains an Apple xcode
++ vstudio => Contains a Microsoft Visual C++ (MSVC)
+ workspace for building libpng and zlib
+ scripts => Directory containing scripts for building libpng:
+ (see scripts/README.txt for the list of scripts)
+--- ./jdk/src/share/native/sun/awt/libpng/png.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/png.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.16 [December 22, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -42,7 +42,7 @@
+ #include "pngpriv.h"
+
+ /* Generate a compiler error if there is an old png.h in the search path. */
+-typedef png_libpng_version_1_5_4 Your_png_h_is_not_version_1_5_4;
++typedef png_libpng_version_1_6_16 Your_png_h_is_not_version_1_6_16;
+
+ /* Tells libpng that we have already handled the first "num_bytes" bytes
+ * of the PNG file signature. If the PNG data is embedded into another
+@@ -52,7 +52,7 @@
+
+ #ifdef PNG_READ_SUPPORTED
+ void PNGAPI
+-png_set_sig_bytes(png_structp png_ptr, int num_bytes)
++png_set_sig_bytes(png_structrp png_ptr, int num_bytes)
+ {
+ png_debug(1, "in png_set_sig_bytes");
+
+@@ -71,7 +71,7 @@
+ * can simply check the remaining bytes for extra assurance. Returns
+ * an integer less than, equal to, or greater than zero if sig is found,
+ * respectively, to be less than, to match, or be greater than the correct
+- * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
++ * PNG signature (this is the same behavior as strcmp, memcmp, etc).
+ */
+ int PNGAPI
+ png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
+@@ -90,52 +90,47 @@
+ if (start + num_to_check > 8)
+ num_to_check = 8 - start;
+
+- return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
++ return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));
+ }
+
+-#endif /* PNG_READ_SUPPORTED */
++#endif /* READ */
+
+ #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+ /* Function to allocate memory for zlib */
+ PNG_FUNCTION(voidpf /* PRIVATE */,
+ png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
+ {
+- png_voidp ptr;
+- png_structp p=(png_structp)png_ptr;
+- png_uint_32 save_flags=p->flags;
+- png_alloc_size_t num_bytes;
++ png_alloc_size_t num_bytes = size;
+
+ if (png_ptr == NULL)
+- return (NULL);
+-
+- if (items > PNG_UINT_32_MAX/size)
++ return NULL;
++
++ if (items >= (~(png_alloc_size_t)0)/size)
+ {
+- png_warning (p, "Potential overflow in png_zalloc()");
+- return (NULL);
++ png_warning (png_voidcast(png_structrp, png_ptr),
++ "Potential overflow in png_zalloc()");
++ return NULL;
+ }
+- num_bytes = (png_alloc_size_t)items * size;
+-
+- p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+- ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
+- p->flags=save_flags;
+-
+- return ((voidpf)ptr);
++
++ num_bytes *= items;
++ return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);
+ }
+
+ /* Function to free memory for zlib */
+ void /* PRIVATE */
+ png_zfree(voidpf png_ptr, voidpf ptr)
+ {
+- png_free((png_structp)png_ptr, (png_voidp)ptr);
++ png_free(png_voidcast(png_const_structrp,png_ptr), ptr);
+ }
+
+ /* Reset the CRC variable to 32 bits of 1's. Care must be taken
+ * in case CRC is > 32 bits to leave the top bits 0.
+ */
+ void /* PRIVATE */
+-png_reset_crc(png_structp png_ptr)
++png_reset_crc(png_structrp png_ptr)
+ {
+- png_ptr->crc = crc32(0, Z_NULL, 0);
++ /* The cast is safe because the crc is a 32 bit value. */
++ png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);
+ }
+
+ /* Calculate the CRC over a section of data. We can only pass as
+@@ -144,119 +139,254 @@
+ * trouble of calculating it.
+ */
+ void /* PRIVATE */
+-png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length)
++png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
+ {
+ int need_crc = 1;
+
+- if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
++ if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
+ {
+ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
+ (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
+ need_crc = 0;
+ }
+
+- else /* critical */
++ else /* critical */
+ {
+- if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
++ if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
+ need_crc = 0;
+ }
+
+- if (need_crc)
+- png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
++ /* 'uLong' is defined in zlib.h as unsigned long; this means that on some
++ * systems it is a 64 bit value. crc32, however, returns 32 bits so the
++ * following cast is safe. 'uInt' may be no more than 16 bits, so it is
++ * necessary to perform a loop here.
++ */
++ if (need_crc != 0 && length > 0)
++ {
++ uLong crc = png_ptr->crc; /* Should never issue a warning */
++
++ do
++ {
++ uInt safe_length = (uInt)length;
++ if (safe_length == 0)
++ safe_length = (uInt)-1; /* evil, but safe */
++
++ crc = crc32(crc, ptr, safe_length);
++
++ /* The following should never issue compiler warnings; if they do the
++ * target system has characteristics that will probably violate other
++ * assumptions within the libpng code.
++ */
++ ptr += safe_length;
++ length -= safe_length;
++ }
++ while (length > 0);
++
++ /* And the following is always safe because the crc is only 32 bits. */
++ png_ptr->crc = (png_uint_32)crc;
++ }
+ }
+
+ /* Check a user supplied version number, called from both read and write
+- * functions that create a png_struct
++ * functions that create a png_struct.
+ */
+ int
+-png_user_version_check(png_structp png_ptr, png_const_charp user_png_ver)
++png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
+ {
+- if (user_png_ver)
++ /* Libpng versions 1.0.0 and later are binary compatible if the version
++ * string matches through the second '.'; we must recompile any
++ * applications that use any older library version.
++ */
++
++ if (user_png_ver != NULL)
+ {
+- int i = 0;
++ int i = -1;
++ int found_dots = 0;
+
+ do
+ {
+- if (user_png_ver[i] != png_libpng_ver[i])
++ i++;
++ if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i])
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+- } while (png_libpng_ver[i++]);
++ if (user_png_ver[i] == '.')
++ found_dots++;
++ } while (found_dots < 2 && user_png_ver[i] != 0 &&
++ PNG_LIBPNG_VER_STRING[i] != 0);
+ }
+
+ else
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+
+- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
++ if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0)
+ {
+- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
+- * we must recompile any applications that use any older library version.
+- * For versions after libpng 1.0, we will be compatible, so we need
+- * only check the first digit.
+- */
+- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
+- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
+- (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
+- {
+ #ifdef PNG_WARNINGS_SUPPORTED
+- size_t pos = 0;
+- char m[128];
+-
+- pos = png_safecat(m, sizeof m, pos, "Application built with libpng-");
+- pos = png_safecat(m, sizeof m, pos, user_png_ver);
+- pos = png_safecat(m, sizeof m, pos, " but running with ");
+- pos = png_safecat(m, sizeof m, pos, png_libpng_ver);
+-
+- png_warning(png_ptr, m);
++ size_t pos = 0;
++ char m[128];
++
++ pos = png_safecat(m, (sizeof m), pos,
++ "Application built with libpng-");
++ pos = png_safecat(m, (sizeof m), pos, user_png_ver);
++ pos = png_safecat(m, (sizeof m), pos, " but running with ");
++ pos = png_safecat(m, (sizeof m), pos, PNG_LIBPNG_VER_STRING);
++ PNG_UNUSED(pos)
++
++ png_warning(png_ptr, m);
+ #endif
+
+ #ifdef PNG_ERROR_NUMBERS_SUPPORTED
+- png_ptr->flags = 0;
++ png_ptr->flags = 0;
+ #endif
+
+- return 0;
+- }
++ return 0;
+ }
+
+ /* Success return. */
+ return 1;
+ }
+
+-/* Allocate the memory for an info_struct for the application. We don't
+- * really need the png_ptr, but it could potentially be useful in the
+- * future. This should be used in favour of malloc(png_sizeof(png_info))
+- * and png_info_init() so that applications that want to use a shared
+- * libpng don't have to be recompiled if png_info changes size.
++/* Generic function to create a png_struct for either read or write - this
++ * contains the common initialization.
+ */
++PNG_FUNCTION(png_structp /* PRIVATE */,
++png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
++ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
++ png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
++{
++ png_struct create_struct;
++# ifdef PNG_SETJMP_SUPPORTED
++ jmp_buf create_jmp_buf;
++# endif
++
++ /* This temporary stack-allocated structure is used to provide a place to
++ * build enough context to allow the user provided memory allocator (if any)
++ * to be called.
++ */
++ memset(&create_struct, 0, (sizeof create_struct));
++
++ /* Added at libpng-1.2.6 */
++# ifdef PNG_USER_LIMITS_SUPPORTED
++ create_struct.user_width_max = PNG_USER_WIDTH_MAX;
++ create_struct.user_height_max = PNG_USER_HEIGHT_MAX;
++
++# ifdef PNG_USER_CHUNK_CACHE_MAX
++ /* Added at libpng-1.2.43 and 1.4.0 */
++ create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
++# endif
++
++# ifdef PNG_USER_CHUNK_MALLOC_MAX
++ /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists
++ * in png_struct regardless.
++ */
++ create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
++# endif
++# endif
++
++ /* The following two API calls simply set fields in png_struct, so it is safe
++ * to do them now even though error handling is not yet set up.
++ */
++# ifdef PNG_USER_MEM_SUPPORTED
++ png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);
++# else
++ PNG_UNUSED(mem_ptr)
++ PNG_UNUSED(malloc_fn)
++ PNG_UNUSED(free_fn)
++# endif
++
++ /* (*error_fn) can return control to the caller after the error_ptr is set,
++ * this will result in a memory leak unless the error_fn does something
++ * extremely sophisticated. The design lacks merit but is implicit in the
++ * API.
++ */
++ png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);
++
++# ifdef PNG_SETJMP_SUPPORTED
++ if (!setjmp(create_jmp_buf))
++ {
++ /* Temporarily fake out the longjmp information until we have
++ * successfully completed this function. This only works if we have
++ * setjmp() support compiled in, but it is safe - this stuff should
++ * never happen.
++ */
++ create_struct.jmp_buf_ptr = &create_jmp_buf;
++ create_struct.jmp_buf_size = 0; /*stack allocation*/
++ create_struct.longjmp_fn = longjmp;
++# else
++ {
++# endif
++ /* Call the general version checker (shared with read and write code):
++ */
++ if (png_user_version_check(&create_struct, user_png_ver) != 0)
++ {
++ png_structrp png_ptr = png_voidcast(png_structrp,
++ png_malloc_warn(&create_struct, (sizeof *png_ptr)));
++
++ if (png_ptr != NULL)
++ {
++ /* png_ptr->zstream holds a back-pointer to the png_struct, so
++ * this can only be done now:
++ */
++ create_struct.zstream.zalloc = png_zalloc;
++ create_struct.zstream.zfree = png_zfree;
++ create_struct.zstream.opaque = png_ptr;
++
++# ifdef PNG_SETJMP_SUPPORTED
++ /* Eliminate the local error handling: */
++ create_struct.jmp_buf_ptr = NULL;
++ create_struct.jmp_buf_size = 0;
++ create_struct.longjmp_fn = 0;
++# endif
++
++ *png_ptr = create_struct;
++
++ /* This is the successful return point */
++ return png_ptr;
++ }
++ }
++ }
++
++ /* A longjmp because of a bug in the application storage allocator or a
++ * simple failure to allocate the png_struct.
++ */
++ return NULL;
++}
++
++/* Allocate the memory for an info_struct for the application. */
+ PNG_FUNCTION(png_infop,PNGAPI
+-png_create_info_struct,(png_structp png_ptr),PNG_ALLOCATED)
++png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)
+ {
+- png_infop info_ptr;
++ png_inforp info_ptr;
+
+ png_debug(1, "in png_create_info_struct");
+
+ if (png_ptr == NULL)
+- return (NULL);
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
+- png_ptr->malloc_fn, png_ptr->mem_ptr);
+-#else
+- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
+-#endif
++ return NULL;
++
++ /* Use the internal API that does not (or at least should not) error out, so
++ * that this call always returns ok. The application typically sets up the
++ * error handling *after* creating the info_struct because this is the way it
++ * has always been done in 'example.c'.
++ */
++ info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
++ (sizeof *info_ptr)));
++
+ if (info_ptr != NULL)
+- png_info_init_3(&info_ptr, png_sizeof(png_info));
+-
+- return (info_ptr);
++ memset(info_ptr, 0, (sizeof *info_ptr));
++
++ return info_ptr;
+ }
+
+ /* This function frees the memory associated with a single info struct.
+ * Normally, one would use either png_destroy_read_struct() or
+ * png_destroy_write_struct() to free an info struct, but this may be
+- * useful for some applications.
++ * useful for some applications. From libpng 1.6.0 this function is also used
++ * internally to implement the png_info release part of the 'struct' destroy
++ * APIs. This ensures that all possible approaches free the same data (all of
++ * it).
+ */
+ void PNGAPI
+-png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
++png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
+ {
+- png_infop info_ptr = NULL;
++ png_inforp info_ptr = NULL;
+
+ png_debug(1, "in png_destroy_info_struct");
+
+@@ -268,46 +398,57 @@
+
+ if (info_ptr != NULL)
+ {
+- png_info_destroy(png_ptr, info_ptr);
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
+- png_ptr->mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)info_ptr);
+-#endif
++ /* Do this first in case of an error below; if the app implements its own
++ * memory management this can lead to png_free calling png_error, which
++ * will abort this routine and return control to the app error handler.
++ * An infinite loop may result if it then tries to free the same info
++ * ptr.
++ */
+ *info_ptr_ptr = NULL;
++
++ png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
++ memset(info_ptr, 0, (sizeof *info_ptr));
++ png_free(png_ptr, info_ptr);
+ }
+ }
+
+ /* Initialize the info structure. This is now an internal function (0.89)
+ * and applications using it are urged to use png_create_info_struct()
+- * instead.
++ * instead. Use deprecated in 1.6.0, internal use removed (used internally it
++ * is just a memset).
++ *
++ * NOTE: it is almost inconceivable that this API is used because it bypasses
++ * the user-memory mechanism and the user error handling/warning mechanisms in
++ * those cases where it does anything other than a memset.
+ */
+-
+-void PNGAPI
+-png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
++PNG_FUNCTION(void,PNGAPI
++png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
++ PNG_DEPRECATED)
+ {
+- png_infop info_ptr = *ptr_ptr;
++ png_inforp info_ptr = *ptr_ptr;
+
+ png_debug(1, "in png_info_init_3");
+
+ if (info_ptr == NULL)
+ return;
+
+- if (png_sizeof(png_info) > png_info_struct_size)
++ if ((sizeof (png_info)) > png_info_struct_size)
+ {
+- png_destroy_struct(info_ptr);
+- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
++ *ptr_ptr = NULL;
++ /* The following line is why this API should not be used: */
++ free(info_ptr);
++ info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,
++ (sizeof *info_ptr)));
+ *ptr_ptr = info_ptr;
+ }
+
+ /* Set everything to 0 */
+- png_memset(info_ptr, 0, png_sizeof(png_info));
++ memset(info_ptr, 0, (sizeof *info_ptr));
+ }
+
++/* The following API is not called internally */
+ void PNGAPI
+-png_data_freer(png_structp png_ptr, png_infop info_ptr,
++png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,
+ int freer, png_uint_32 mask)
+ {
+ png_debug(1, "in png_data_freer");
+@@ -322,12 +463,11 @@
+ info_ptr->free_me &= ~mask;
+
+ else
+- png_warning(png_ptr,
+- "Unknown freer parameter in png_data_freer");
++ png_error(png_ptr, "Unknown freer parameter in png_data_freer");
+ }
+
+ void PNGAPI
+-png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
++png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
+ int num)
+ {
+ png_debug(1, "in png_free_data");
+@@ -337,32 +477,32 @@
+
+ #ifdef PNG_TEXT_SUPPORTED
+ /* Free text item num or (if num == -1) all text items */
+- if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
++ if (info_ptr->text != 0 &&
++ ((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0)
+ {
+ if (num != -1)
+ {
+- if (info_ptr->text && info_ptr->text[num].key)
+- {
+- png_free(png_ptr, info_ptr->text[num].key);
+- info_ptr->text[num].key = NULL;
+- }
++ png_free(png_ptr, info_ptr->text[num].key);
++ info_ptr->text[num].key = NULL;
+ }
+
+ else
+ {
+ int i;
++
+ for (i = 0; i < info_ptr->num_text; i++)
+- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
++ png_free(png_ptr, info_ptr->text[i].key);
++
+ png_free(png_ptr, info_ptr->text);
+ info_ptr->text = NULL;
+- info_ptr->num_text=0;
++ info_ptr->num_text = 0;
+ }
+ }
+ #endif
+
+ #ifdef PNG_tRNS_SUPPORTED
+ /* Free any tRNS entry */
+- if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
++ if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0)
+ {
+ png_free(png_ptr, info_ptr->trans_alpha);
+ info_ptr->trans_alpha = NULL;
+@@ -372,7 +512,7 @@
+
+ #ifdef PNG_sCAL_SUPPORTED
+ /* Free any sCAL entry */
+- if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
++ if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0)
+ {
+ png_free(png_ptr, info_ptr->scal_s_width);
+ png_free(png_ptr, info_ptr->scal_s_height);
+@@ -384,20 +524,20 @@
+
+ #ifdef PNG_pCAL_SUPPORTED
+ /* Free any pCAL entry */
+- if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
++ if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0)
+ {
+ png_free(png_ptr, info_ptr->pcal_purpose);
+ png_free(png_ptr, info_ptr->pcal_units);
+ info_ptr->pcal_purpose = NULL;
+ info_ptr->pcal_units = NULL;
++
+ if (info_ptr->pcal_params != NULL)
+ {
+ int i;
+- for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
+- {
++
++ for (i = 0; i < info_ptr->pcal_nparams; i++)
+ png_free(png_ptr, info_ptr->pcal_params[i]);
+- info_ptr->pcal_params[i] = NULL;
+- }
++
+ png_free(png_ptr, info_ptr->pcal_params);
+ info_ptr->pcal_params = NULL;
+ }
+@@ -406,8 +546,8 @@
+ #endif
+
+ #ifdef PNG_iCCP_SUPPORTED
+- /* Free any iCCP entry */
+- if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
++ /* Free any profile entry */
++ if (((mask & PNG_FREE_ICCP) & info_ptr->free_me) != 0)
+ {
+ png_free(png_ptr, info_ptr->iccp_name);
+ png_free(png_ptr, info_ptr->iccp_profile);
+@@ -419,26 +559,28 @@
+
+ #ifdef PNG_sPLT_SUPPORTED
+ /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
+- if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
++ if (info_ptr->splt_palettes != 0 &&
++ ((mask & PNG_FREE_SPLT) & info_ptr->free_me) != 0)
+ {
+ if (num != -1)
+ {
+- if (info_ptr->splt_palettes)
+- {
+- png_free(png_ptr, info_ptr->splt_palettes[num].name);
+- png_free(png_ptr, info_ptr->splt_palettes[num].entries);
+- info_ptr->splt_palettes[num].name = NULL;
+- info_ptr->splt_palettes[num].entries = NULL;
+- }
++ png_free(png_ptr, info_ptr->splt_palettes[num].name);
++ png_free(png_ptr, info_ptr->splt_palettes[num].entries);
++ info_ptr->splt_palettes[num].name = NULL;
++ info_ptr->splt_palettes[num].entries = NULL;
+ }
+
+ else
+ {
+- if (info_ptr->splt_palettes_num)
++ if (info_ptr->splt_palettes_num != 0)
+ {
+ int i;
+- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
+- png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
++
++ for (i = 0; i < info_ptr->splt_palettes_num; i++)
++ {
++ png_free(png_ptr, info_ptr->splt_palettes[i].name);
++ png_free(png_ptr, info_ptr->splt_palettes[i].entries);
++ }
+
+ png_free(png_ptr, info_ptr->splt_palettes);
+ info_ptr->splt_palettes = NULL;
+@@ -449,32 +591,24 @@
+ }
+ #endif
+
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+- if (png_ptr->unknown_chunk.data)
+- {
+- png_free(png_ptr, png_ptr->unknown_chunk.data);
+- png_ptr->unknown_chunk.data = NULL;
+- }
+-
+- if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
++ if (info_ptr->unknown_chunks != 0 &&
++ ((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0)
+ {
+ if (num != -1)
+ {
+- if (info_ptr->unknown_chunks)
+- {
+- png_free(png_ptr, info_ptr->unknown_chunks[num].data);
+- info_ptr->unknown_chunks[num].data = NULL;
+- }
++ png_free(png_ptr, info_ptr->unknown_chunks[num].data);
++ info_ptr->unknown_chunks[num].data = NULL;
+ }
+
+ else
+ {
+ int i;
+
+- if (info_ptr->unknown_chunks_num)
++ if (info_ptr->unknown_chunks_num != 0)
+ {
+ for (i = 0; i < info_ptr->unknown_chunks_num; i++)
+- png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
++ png_free(png_ptr, info_ptr->unknown_chunks[i].data);
+
+ png_free(png_ptr, info_ptr->unknown_chunks);
+ info_ptr->unknown_chunks = NULL;
+@@ -486,7 +620,7 @@
+
+ #ifdef PNG_hIST_SUPPORTED
+ /* Free any hIST entry */
+- if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
++ if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0)
+ {
+ png_free(png_ptr, info_ptr->hist);
+ info_ptr->hist = NULL;
+@@ -495,9 +629,9 @@
+ #endif
+
+ /* Free any PLTE entry that was internally allocated */
+- if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
++ if (((mask & PNG_FREE_PLTE) & info_ptr->free_me) != 0)
+ {
+- png_zfree(png_ptr, info_ptr->palette);
++ png_free(png_ptr, info_ptr->palette);
+ info_ptr->palette = NULL;
+ info_ptr->valid &= ~PNG_INFO_PLTE;
+ info_ptr->num_palette = 0;
+@@ -505,16 +639,14 @@
+
+ #ifdef PNG_INFO_IMAGE_SUPPORTED
+ /* Free any image bits attached to the info structure */
+- if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
++ if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0)
+ {
+- if (info_ptr->row_pointers)
++ if (info_ptr->row_pointers != 0)
+ {
+- int row;
+- for (row = 0; row < (int)info_ptr->height; row++)
+- {
++ png_uint_32 row;
++ for (row = 0; row < info_ptr->height; row++)
+ png_free(png_ptr, info_ptr->row_pointers[row]);
+- info_ptr->row_pointers[row] = NULL;
+- }
++
+ png_free(png_ptr, info_ptr->row_pointers);
+ info_ptr->row_pointers = NULL;
+ }
+@@ -527,37 +659,14 @@
+
+ info_ptr->free_me &= ~mask;
+ }
+-
+-/* This is an internal routine to free any memory that the info struct is
+- * pointing to before re-using it or freeing the struct itself. Recall
+- * that png_free() checks for NULL pointers for us.
+- */
+-void /* PRIVATE */
+-png_info_destroy(png_structp png_ptr, png_infop info_ptr)
+-{
+- png_debug(1, "in png_info_destroy");
+-
+- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+-
+-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- if (png_ptr->num_chunk_list)
+- {
+- png_free(png_ptr, png_ptr->chunk_list);
+- png_ptr->chunk_list = NULL;
+- png_ptr->num_chunk_list = 0;
+- }
+-#endif
+-
+- png_info_init_3(&info_ptr, png_sizeof(png_info));
+-}
+-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
++#endif /* READ || WRITE */
+
+ /* This function returns a pointer to the io_ptr associated with the user
+ * functions. The application should free any memory associated with this
+ * pointer before png_write_destroy() or png_read_destroy() are called.
+ */
+ png_voidp PNGAPI
+-png_get_io_ptr(png_structp png_ptr)
++png_get_io_ptr(png_const_structrp png_ptr)
+ {
+ if (png_ptr == NULL)
+ return (NULL);
+@@ -570,11 +679,11 @@
+ /* Initialize the default input/output functions for the PNG file. If you
+ * use your own read or write routines, you can call either png_set_read_fn()
+ * or png_set_write_fn() instead of png_init_io(). If you have defined
+- * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
+- * necessarily available.
++ * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a
++ * function of your own because "FILE *" isn't necessarily available.
+ */
+ void PNGAPI
+-png_init_io(png_structp png_ptr, png_FILE_p fp)
++png_init_io(png_structrp png_ptr, png_FILE_p fp)
+ {
+ png_debug(1, "in png_init_io");
+
+@@ -585,44 +694,64 @@
+ }
+ # endif
+
++#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 extension.)
++ */
++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
++
+ # ifdef PNG_TIME_RFC1123_SUPPORTED
+ /* Convert the supplied time into an RFC 1123 string suitable for use in
+ * a "Creation Time" or other text-based time string.
+ */
+-png_const_charp PNGAPI
+-png_convert_to_rfc1123(png_structp png_ptr, png_const_timep ptime)
++int PNGAPI
++png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
+ {
+ static PNG_CONST char short_months[12][4] =
+ {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+- if (png_ptr == NULL)
+- return (NULL);
++ if (out == NULL)
++ return 0;
++
++ if (ptime->year > 9999 /* RFC1123 limitation */ ||
++ ptime->month == 0 || ptime->month > 12 ||
++ ptime->day == 0 || ptime->day > 31 ||
++ ptime->hour > 23 || ptime->minute > 59 ||
++ ptime->second > 60)
++ return 0;
+
+ {
+ size_t pos = 0;
+- char number_buf[5]; /* enough for a four digit year */
+-
+-# define APPEND_STRING(string)\
+- pos = png_safecat(png_ptr->time_buffer, sizeof png_ptr->time_buffer,\
+- pos, (string))
++ char number_buf[5]; /* enough for a four-digit year */
++
++# define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string))
+ # define APPEND_NUMBER(format, value)\
+ APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))
+-# define APPEND(ch)\
+- if (pos < (sizeof png_ptr->time_buffer)-1)\
+- png_ptr->time_buffer[pos++] = (ch)
+-
+- APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day % 32);
++# define APPEND(ch) if (pos < 28) out[pos++] = (ch)
++
++ APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);
+ APPEND(' ');
+- APPEND_STRING(short_months[(ptime->month - 1) % 12]);
++ APPEND_STRING(short_months[(ptime->month - 1)]);
+ APPEND(' ');
+ APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);
+ APPEND(' ');
+- APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour % 24);
++ APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);
+ APPEND(':');
+- APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute % 60);
++ APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);
+ APPEND(':');
+- APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second % 61);
++ APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);
+ APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
+
+ # undef APPEND
+@@ -630,14 +759,37 @@
+ # undef APPEND_STRING
+ }
+
+- return png_ptr->time_buffer;
++ return 1;
+ }
+-# endif /* PNG_TIME_RFC1123_SUPPORTED */
+-
+-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
+-
++
++# if PNG_LIBPNG_VER < 10700
++/* To do: remove the following from libpng-1.7 */
++/* Original API that uses a private buffer in png_struct.
++ * Deprecated because it causes png_struct to carry a spurious temporary
++ * buffer (png_struct::time_buffer), better to have the caller pass this in.
++ */
+ png_const_charp PNGAPI
+-png_get_copyright(png_const_structp png_ptr)
++png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime)
++{
++ if (png_ptr != NULL)
++ {
++ /* The only failure above if png_ptr != NULL is from an invalid ptime */
++ if (png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime) == 0)
++ png_warning(png_ptr, "Ignoring invalid time value");
++
++ else
++ return png_ptr->time_buffer;
++ }
++
++ return NULL;
++}
++# endif
++# endif /* TIME_RFC1123 */
++
++#endif /* READ || WRITE */
++
++png_const_charp PNGAPI
++png_get_copyright(png_const_structrp png_ptr)
+ {
+ PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
+ #ifdef PNG_STRING_COPYRIGHT
+@@ -645,14 +797,14 @@
+ #else
+ # ifdef __STDC__
+ return PNG_STRING_NEWLINE \
+- "libpng version 1.5.4 - July 7, 2011" PNG_STRING_NEWLINE \
+- "Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
++ "libpng version 1.6.16 - December 22, 2014" PNG_STRING_NEWLINE \
++ "Copyright (c) 1998-2014 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
+ "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
+ "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
+ PNG_STRING_NEWLINE;
+ # else
+- return "libpng version 1.5.4 - July 7, 2011\
+- Copyright (c) 1998-2011 Glenn Randers-Pehrson\
++ return "libpng version 1.6.16 - December 22, 2014\
++ Copyright (c) 1998-2014 Glenn Randers-Pehrson\
+ Copyright (c) 1996-1997 Andreas Dilger\
+ Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
+ # endif
+@@ -668,14 +820,14 @@
+ * it is guaranteed that png.c uses the correct version of png.h.
+ */
+ png_const_charp PNGAPI
+-png_get_libpng_ver(png_const_structp png_ptr)
++png_get_libpng_ver(png_const_structrp png_ptr)
+ {
+ /* Version of *.c files used when building libpng */
+ return png_get_header_ver(png_ptr);
+ }
+
+ png_const_charp PNGAPI
+-png_get_header_ver(png_const_structp png_ptr)
++png_get_header_ver(png_const_structrp png_ptr)
+ {
+ /* Version of *.h files used when building libpng */
+ PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
+@@ -683,7 +835,7 @@
+ }
+
+ png_const_charp PNGAPI
+-png_get_header_version(png_const_structp png_ptr)
++png_get_header_version(png_const_structrp png_ptr)
+ {
+ /* Returns longer string containing both version and date */
+ PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
+@@ -698,37 +850,122 @@
+ #endif
+ }
+
+-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+-# ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
++/* NOTE: this routine is not used internally! */
++/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
++ * large of png_color. This lets grayscale images be treated as
++ * paletted. Most useful for gamma correction and simplification
++ * of code. This API is not used internally.
++ */
++void PNGAPI
++png_build_grayscale_palette(int bit_depth, png_colorp palette)
++{
++ int num_palette;
++ int color_inc;
++ int i;
++ int v;
++
++ png_debug(1, "in png_do_build_grayscale_palette");
++
++ if (palette == NULL)
++ return;
++
++ switch (bit_depth)
++ {
++ case 1:
++ num_palette = 2;
++ color_inc = 0xff;
++ break;
++
++ case 2:
++ num_palette = 4;
++ color_inc = 0x55;
++ break;
++
++ case 4:
++ num_palette = 16;
++ color_inc = 0x11;
++ break;
++
++ case 8:
++ num_palette = 256;
++ color_inc = 1;
++ break;
++
++ default:
++ num_palette = 0;
++ color_inc = 0;
++ break;
++ }
++
++ for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
++ {
++ palette[i].red = (png_byte)v;
++ palette[i].green = (png_byte)v;
++ palette[i].blue = (png_byte)v;
++ }
++}
++#endif
++
++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
+ int PNGAPI
+-png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name)
++png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)
+ {
+ /* Check chunk_name and return "keep" value if it's on the list, else 0 */
+- int i;
+- png_bytep p;
+- if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
+- return 0;
+-
+- p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;
+- for (i = png_ptr->num_chunk_list; i; i--, p -= 5)
+- if (!png_memcmp(chunk_name, p, 4))
+- return ((int)*(p + 4));
+- return 0;
++ png_const_bytep p, p_end;
++
++ if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)
++ return PNG_HANDLE_CHUNK_AS_DEFAULT;
++
++ p_end = png_ptr->chunk_list;
++ p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
++
++ /* The code is the fifth byte after each four byte string. Historically this
++ * code was always searched from the end of the list, this is no longer
++ * necessary because the 'set' routine handles duplicate entries correcty.
++ */
++ do /* num_chunk_list > 0, so at least one */
++ {
++ p -= 5;
++
++ if (memcmp(chunk_name, p, 4) == 0)
++ return p[4];
++ }
++ while (p > p_end);
++
++ /* This means that known chunks should be processed and unknown chunks should
++ * be handled according to the value of png_ptr->unknown_default; this can be
++ * confusing because, as a result, there are two levels of defaulting for
++ * unknown chunks.
++ */
++ return PNG_HANDLE_CHUNK_AS_DEFAULT;
+ }
+-# endif
+-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
++
++#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
++ defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
++int /* PRIVATE */
++png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)
++{
++ png_byte chunk_string[5];
++
++ PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);
++ return png_handle_as_unknown(png_ptr, chunk_string);
++}
++#endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
++#endif /* SET_UNKNOWN_CHUNKS */
+
+ #ifdef PNG_READ_SUPPORTED
+ /* This function, added to libpng-1.0.6g, is untested. */
+ int PNGAPI
+-png_reset_zstream(png_structp png_ptr)
++png_reset_zstream(png_structrp png_ptr)
+ {
+ if (png_ptr == NULL)
+ return Z_STREAM_ERROR;
+
++ /* WARNING: this resets the window bits to the maximum! */
+ return (inflateReset(&png_ptr->zstream));
+ }
+-#endif /* PNG_READ_SUPPORTED */
++#endif /* READ */
+
+ /* This function was added to libpng-1.0.7 */
+ png_uint_32 PNGAPI
+@@ -741,93 +978,1530 @@
+
+
+ #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+-# ifdef PNG_SIZE_T
+-/* Added at libpng version 1.2.6 */
+- PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
+-png_size_t PNGAPI
+-png_convert_size(size_t size)
++/* Ensure that png_ptr->zstream.msg holds some appropriate error message string.
++ * If it doesn't 'ret' is used to set it to something appropriate, even in cases
++ * like Z_OK or Z_STREAM_END where the error code is apparently a success code.
++ */
++void /* PRIVATE */
++png_zstream_error(png_structrp png_ptr, int ret)
+ {
+- if (size > (png_size_t)-1)
+- PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */
+-
+- return ((png_size_t)size);
++ /* Translate 'ret' into an appropriate error string, priority is given to the
++ * one in zstream if set. This always returns a string, even in cases like
++ * Z_OK or Z_STREAM_END where the error code is a success code.
++ */
++ if (png_ptr->zstream.msg == NULL) switch (ret)
++ {
++ default:
++ case Z_OK:
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");
++ break;
++
++ case Z_STREAM_END:
++ /* Normal exit */
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");
++ break;
++
++ case Z_NEED_DICT:
++ /* This means the deflate stream did not have a dictionary; this
++ * indicates a bogus PNG.
++ */
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");
++ break;
++
++ case Z_ERRNO:
++ /* gz APIs only: should not happen */
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");
++ break;
++
++ case Z_STREAM_ERROR:
++ /* internal libpng error */
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");
++ break;
++
++ case Z_DATA_ERROR:
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");
++ break;
++
++ case Z_MEM_ERROR:
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");
++ break;
++
++ case Z_BUF_ERROR:
++ /* End of input or output; not a problem if the caller is doing
++ * incremental read or write.
++ */
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");
++ break;
++
++ case Z_VERSION_ERROR:
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");
++ break;
++
++ case PNG_UNEXPECTED_ZLIB_RETURN:
++ /* Compile errors here mean that zlib now uses the value co-opted in
++ * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above
++ * and change pngpriv.h. Note that this message is "... return",
++ * whereas the default/Z_OK one is "... return code".
++ */
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");
++ break;
++ }
+ }
+-# endif /* PNG_SIZE_T */
++
++/* png_convert_size: a PNGAPI but no longer in png.h, so deleted
++ * at libpng 1.5.5!
++ */
+
+ /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
+-# ifdef PNG_CHECK_cHRM_SUPPORTED
++#ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */
++static int
++png_colorspace_check_gamma(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, png_fixed_point gAMA, int from)
++ /* This is called to check a new gamma value against an existing one. The
++ * routine returns false if the new gamma value should not be written.
++ *
++ * 'from' says where the new gamma value comes from:
++ *
++ * 0: the new gamma value is the libpng estimate for an ICC profile
++ * 1: the new gamma value comes from a gAMA chunk
++ * 2: the new gamma value comes from an sRGB chunk
++ */
++{
++ png_fixed_point gtest;
++
++ if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
++ (png_muldiv(&gtest, colorspace->gamma, PNG_FP_1, gAMA) == 0 ||
++ png_gamma_significant(gtest) != 0))
++ {
++ /* Either this is an sRGB image, in which case the calculated gamma
++ * approximation should match, or this is an image with a profile and the
++ * value libpng calculates for the gamma of the profile does not match the
++ * value recorded in the file. The former, sRGB, case is an error, the
++ * latter is just a warning.
++ */
++ if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)
++ {
++ png_chunk_report(png_ptr, "gamma value does not match sRGB",
++ PNG_CHUNK_ERROR);
++ /* Do not overwrite an sRGB value */
++ return from == 2;
++ }
++
++ else /* sRGB tag not involved */
++ {
++ png_chunk_report(png_ptr, "gamma value does not match libpng estimate",
++ PNG_CHUNK_WARNING);
++ return from == 1;
++ }
++ }
++
++ return 1;
++}
++
++void /* PRIVATE */
++png_colorspace_set_gamma(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, png_fixed_point gAMA)
++{
++ /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
++ * occur. Since the fixed point representation is asymetrical 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.)
++ *
++ * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk
++ * handling code, which only required the value to be >0.
++ */
++ png_const_charp errmsg;
++
++ if (gAMA < 16 || gAMA > 625000000)
++ errmsg = "gamma value out of range";
++
++# ifdef PNG_READ_gAMA_SUPPORTED
++ /* Allow the application to set the gamma value more than once */
++ else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
++ (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)
++ errmsg = "duplicate";
++# endif
++
++ /* Do nothing if the colorspace is already invalid */
++ else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
++ return;
++
++ else
++ {
++ if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA,
++ 1/*from gAMA*/) != 0)
++ {
++ /* Store this gamma value. */
++ colorspace->gamma = gAMA;
++ colorspace->flags |=
++ (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);
++ }
++
++ /* At present if the check_gamma test fails the gamma of the colorspace is
++ * not updated however the colorspace is not invalidated. This
++ * corresponds to the case where the existing gamma comes from an sRGB
++ * chunk or profile. An error message has already been output.
++ */
++ return;
++ }
++
++ /* Error exit - errmsg has been set. */
++ colorspace->flags |= PNG_COLORSPACE_INVALID;
++ png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);
++}
++
++void /* PRIVATE */
++png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
++{
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
++ {
++ /* Everything is invalid */
++ info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|
++ PNG_INFO_iCCP);
++
++# ifdef PNG_COLORSPACE_SUPPORTED
++ /* Clean up the iCCP profile now if it won't be used. */
++ png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);
++# else
++ PNG_UNUSED(png_ptr)
++# endif
++ }
++
++ else
++ {
++# ifdef PNG_COLORSPACE_SUPPORTED
++ /* Leave the INFO_iCCP flag set if the pngset.c code has already set
++ * it; this allows a PNG to contain a profile which matches sRGB and
++ * yet still have that profile retrievable by the application.
++ */
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0)
++ info_ptr->valid |= PNG_INFO_sRGB;
++
++ else
++ info_ptr->valid &= ~PNG_INFO_sRGB;
++
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
++ info_ptr->valid |= PNG_INFO_cHRM;
++
++ else
++ info_ptr->valid &= ~PNG_INFO_cHRM;
++# endif
++
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0)
++ info_ptr->valid |= PNG_INFO_gAMA;
++
++ else
++ info_ptr->valid &= ~PNG_INFO_gAMA;
++ }
++}
++
++#ifdef PNG_READ_SUPPORTED
++void /* PRIVATE */
++png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr)
++{
++ if (info_ptr == NULL) /* reduce code size; check here not in the caller */
++ return;
++
++ info_ptr->colorspace = png_ptr->colorspace;
++ png_colorspace_sync_info(png_ptr, info_ptr);
++}
++#endif
++#endif
++
++#ifdef PNG_COLORSPACE_SUPPORTED
++/* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for
++ * cHRM, as opposed to using chromaticities. These internal APIs return
++ * non-zero on a parameter error. The X, Y and Z values are required to be
++ * positive and less than 1.0.
++ */
++static int
++png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)
++{
++ png_int_32 d, dwhite, whiteX, whiteY;
++
++ d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z;
++ if (png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d) == 0)
++ return 1;
++ if (png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d) == 0)
++ return 1;
++ dwhite = d;
++ whiteX = XYZ->red_X;
++ whiteY = XYZ->red_Y;
++
++ d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z;
++ if (png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d) == 0)
++ return 1;
++ if (png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d) == 0)
++ return 1;
++ dwhite += d;
++ whiteX += XYZ->green_X;
++ whiteY += XYZ->green_Y;
++
++ d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z;
++ if (png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d) == 0)
++ return 1;
++ if (png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d) == 0)
++ return 1;
++ dwhite += d;
++ whiteX += XYZ->blue_X;
++ whiteY += XYZ->blue_Y;
++
++ /* The reference white is simply the sum of the end-point (X,Y,Z) vectors,
++ * thus:
++ */
++ if (png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite) == 0)
++ return 1;
++ if (png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite) == 0)
++ return 1;
++
++ return 0;
++}
++
++static int
++png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
++{
++ png_fixed_point red_inverse, green_inverse, blue_scale;
++ png_fixed_point left, right, denominator;
++
++ /* Check xy and, implicitly, z. Note that wide gamut color spaces typically
++ * have end points with 0 tristimulus values (these are impossible end
++ * points, but they are used to cover the possible colors.)
++ */
++ if (xy->redx < 0 || xy->redx > PNG_FP_1) return 1;
++ if (xy->redy < 0 || xy->redy > PNG_FP_1-xy->redx) return 1;
++ if (xy->greenx < 0 || xy->greenx > PNG_FP_1) return 1;
++ if (xy->greeny < 0 || xy->greeny > PNG_FP_1-xy->greenx) return 1;
++ if (xy->bluex < 0 || xy->bluex > PNG_FP_1) return 1;
++ if (xy->bluey < 0 || xy->bluey > PNG_FP_1-xy->bluex) return 1;
++ if (xy->whitex < 0 || xy->whitex > PNG_FP_1) return 1;
++ if (xy->whitey < 0 || xy->whitey > PNG_FP_1-xy->whitex) return 1;
++
++ /* The reverse calculation is more difficult because the original tristimulus
++ * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8
++ * derived values were recorded in the cHRM chunk;
++ * (red,green,blue,white)x(x,y). This loses one degree of freedom and
++ * therefore an arbitrary ninth value has to be introduced to undo the
++ * original transformations.
++ *
++ * Think of the original end-points as points in (X,Y,Z) space. The
++ * chromaticity values (c) have the property:
++ *
++ * C
++ * c = ---------
++ * X + Y + Z
++ *
++ * For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the
++ * three chromaticity values (x,y,z) for each end-point obey the
++ * relationship:
++ *
++ * x + y + z = 1
++ *
++ * This describes the plane in (X,Y,Z) space that intersects each axis at the
++ * value 1.0; call this the chromaticity plane. Thus the chromaticity
++ * calculation has scaled each end-point so that it is on the x+y+z=1 plane
++ * and chromaticity is the intersection of the vector from the origin to the
++ * (X,Y,Z) value with the chromaticity plane.
++ *
++ * To fully invert the chromaticity calculation we would need the three
++ * end-point scale factors, (red-scale, green-scale, blue-scale), but these
++ * were not recorded. Instead we calculated the reference white (X,Y,Z) and
++ * recorded the chromaticity of this. The reference white (X,Y,Z) would have
++ * given all three of the scale factors since:
++ *
++ * color-C = color-c * color-scale
++ * white-C = red-C + green-C + blue-C
++ * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
++ *
++ * But cHRM records only white-x and white-y, so we have lost the white scale
++ * factor:
++ *
++ * white-C = white-c*white-scale
++ *
++ * To handle this the inverse transformation makes an arbitrary assumption
++ * about white-scale:
++ *
++ * Assume: white-Y = 1.0
++ * Hence: white-scale = 1/white-y
++ * Or: red-Y + green-Y + blue-Y = 1.0
++ *
++ * Notice the last statement of the assumption gives an equation in three of
++ * the nine values we want to calculate. 8 more equations come from the
++ * above routine as summarised at the top above (the chromaticity
++ * calculation):
++ *
++ * Given: color-x = color-X / (color-X + color-Y + color-Z)
++ * Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0
++ *
++ * This is 9 simultaneous equations in the 9 variables "color-C" and can be
++ * solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix
++ * determinants, however this is not as bad as it seems because only 28 of
++ * the total of 90 terms in the various matrices are non-zero. Nevertheless
++ * Cramer's rule is notoriously numerically unstable because the determinant
++ * calculation involves the difference of large, but similar, numbers. It is
++ * difficult to be sure that the calculation is stable for real world values
++ * and it is certain that it becomes unstable where the end points are close
++ * together.
++ *
++ * So this code uses the perhaps slightly less optimal but more
++ * understandable and totally obvious approach of calculating color-scale.
++ *
++ * This algorithm depends on the precision in white-scale and that is
++ * (1/white-y), so we can immediately see that as white-y approaches 0 the
++ * accuracy inherent in the cHRM chunk drops off substantially.
++ *
++ * libpng arithmetic: a simple inversion of the above equations
++ * ------------------------------------------------------------
++ *
++ * white_scale = 1/white-y
++ * white-X = white-x * white-scale
++ * white-Y = 1.0
++ * white-Z = (1 - white-x - white-y) * white_scale
++ *
++ * white-C = red-C + green-C + blue-C
++ * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
++ *
++ * This gives us three equations in (red-scale,green-scale,blue-scale) where
++ * all the coefficients are now known:
++ *
++ * red-x*red-scale + green-x*green-scale + blue-x*blue-scale
++ * = white-x/white-y
++ * red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1
++ * red-z*red-scale + green-z*green-scale + blue-z*blue-scale
++ * = (1 - white-x - white-y)/white-y
++ *
++ * In the last equation color-z is (1 - color-x - color-y) so we can add all
++ * three equations together to get an alternative third:
++ *
++ * red-scale + green-scale + blue-scale = 1/white-y = white-scale
++ *
++ * So now we have a Cramer's rule solution where the determinants are just
++ * 3x3 - far more tractible. Unfortunately 3x3 determinants still involve
++ * multiplication of three coefficients so we can't guarantee to avoid
++ * overflow in the libpng fixed point representation. Using Cramer's rule in
++ * floating point is probably a good choice here, but it's not an option for
++ * fixed point. Instead proceed to simplify the first two equations by
++ * eliminating what is likely to be the largest value, blue-scale:
++ *
++ * blue-scale = white-scale - red-scale - green-scale
++ *
++ * Hence:
++ *
++ * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =
++ * (white-x - blue-x)*white-scale
++ *
++ * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =
++ * 1 - blue-y*white-scale
++ *
++ * And now we can trivially solve for (red-scale,green-scale):
++ *
++ * green-scale =
++ * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale
++ * -----------------------------------------------------------
++ * green-x - blue-x
++ *
++ * red-scale =
++ * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale
++ * ---------------------------------------------------------
++ * red-y - blue-y
++ *
++ * Hence:
++ *
++ * red-scale =
++ * ( (green-x - blue-x) * (white-y - blue-y) -
++ * (green-y - blue-y) * (white-x - blue-x) ) / white-y
++ * -------------------------------------------------------------------------
++ * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
++ *
++ * green-scale =
++ * ( (red-y - blue-y) * (white-x - blue-x) -
++ * (red-x - blue-x) * (white-y - blue-y) ) / white-y
++ * -------------------------------------------------------------------------
++ * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
++ *
++ * Accuracy:
++ * The input values have 5 decimal digits of accuracy. The values are all in
++ * the range 0 < value < 1, so simple products are in the same range but may
++ * need up to 10 decimal digits to preserve the original precision and avoid
++ * underflow. Because we are using a 32-bit signed representation we cannot
++ * match this; the best is a little over 9 decimal digits, less than 10.
++ *
++ * The approach used here is to preserve the maximum precision within the
++ * signed representation. Because the red-scale calculation above uses the
++ * difference between two products of values that must be in the range -1..+1
++ * it is sufficient to divide the product by 7; ceil(100,000/32767*2). The
++ * factor is irrelevant in the calculation because it is applied to both
++ * numerator and denominator.
++ *
++ * Note that the values of the differences of the products of the
++ * chromaticities in the above equations tend to be small, for example for
++ * the sRGB chromaticities they are:
++ *
++ * red numerator: -0.04751
++ * green numerator: -0.08788
++ * denominator: -0.2241 (without white-y multiplication)
++ *
++ * The resultant Y coefficients from the chromaticities of some widely used
++ * color space definitions are (to 15 decimal places):
++ *
++ * sRGB
++ * 0.212639005871510 0.715168678767756 0.072192315360734
++ * Kodak ProPhoto
++ * 0.288071128229293 0.711843217810102 0.000085653960605
++ * Adobe RGB
++ * 0.297344975250536 0.627363566255466 0.075291458493998
++ * Adobe Wide Gamut RGB
++ * 0.258728243040113 0.724682314948566 0.016589442011321
++ */
++ /* By the argument, above overflow should be impossible here. The return
++ * value of 2 indicates an internal error to the caller.
++ */
++ if (png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7) == 0)
++ return 2;
++ if (png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7) == 0)
++ return 2;
++ denominator = left - right;
++
++ /* Now find the red numerator. */
++ if (png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
++ return 2;
++ if (png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
++ return 2;
++
++ /* Overflow is possible here and it indicates an extreme set of PNG cHRM
++ * chunk values. This calculation actually returns the reciprocal of the
++ * scale value because this allows us to delay the multiplication of white-y
++ * into the denominator, which tends to produce a small number.
++ */
++ if (png_muldiv(&red_inverse, xy->whitey, denominator, left-right) == 0 ||
++ red_inverse <= xy->whitey /* r+g+b scales = white scale */)
++ return 1;
++
++ /* Similarly for green_inverse: */
++ if (png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
++ return 2;
++ if (png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
++ return 2;
++ if (png_muldiv(&green_inverse, xy->whitey, denominator, left-right) == 0 ||
++ green_inverse <= xy->whitey)
++ return 1;
++
++ /* And the blue scale, the checks above guarantee this can't overflow but it
++ * can still produce 0 for extreme cHRM values.
++ */
++ blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) -
++ png_reciprocal(green_inverse);
++ if (blue_scale <= 0)
++ return 1;
++
++
++ /* And fill in the png_XYZ: */
++ if (png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1,
++ red_inverse) == 0)
++ return 1;
++
++ if (png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1,
++ green_inverse) == 0)
++ return 1;
++
++ if (png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale,
++ PNG_FP_1) == 0)
++ return 1;
++
++ return 0; /*success*/
++}
++
++static int
++png_XYZ_normalize(png_XYZ *XYZ)
++{
++ png_int_32 Y;
++
++ if (XYZ->red_Y < 0 || XYZ->green_Y < 0 || XYZ->blue_Y < 0 ||
++ XYZ->red_X < 0 || XYZ->green_X < 0 || XYZ->blue_X < 0 ||
++ XYZ->red_Z < 0 || XYZ->green_Z < 0 || XYZ->blue_Z < 0)
++ return 1;
++
++ /* Normalize by scaling so the sum of the end-point Y values is PNG_FP_1.
++ * IMPLEMENTATION NOTE: ANSI requires signed overflow not to occur, therefore
++ * relying on addition of two positive values producing a negative one is not
++ * safe.
++ */
++ Y = XYZ->red_Y;
++ if (0x7fffffff - Y < XYZ->green_X)
++ return 1;
++ Y += XYZ->green_Y;
++ if (0x7fffffff - Y < XYZ->blue_X)
++ return 1;
++ Y += XYZ->blue_Y;
++
++ if (Y != PNG_FP_1)
++ {
++ if (png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y) == 0)
++ return 1;
++
++ if (png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y) == 0)
++ return 1;
++
++ if (png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y) == 0)
++ return 1;
++ if (png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y) == 0)
++ return 1;
++ }
++
++ return 0;
++}
++
++static int
++png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)
++{
++ /* Allow an error of +/-0.01 (absolute value) on each chromaticity */
++ if (PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) ||
++ PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) ||
++ PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) ||
++ PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) ||
++ PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) ||
++ PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) ||
++ PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) ||
++ PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta))
++ return 0;
++ return 1;
++}
++
++/* Added in libpng-1.6.0, a different check for the validity of a set of cHRM
++ * chunk chromaticities. Earlier checks used to simply look for the overflow
++ * condition (where the determinant of the matrix to solve for XYZ ends up zero
++ * because the chromaticity values are not all distinct.) Despite this it is
++ * theoretically possible to produce chromaticities that are apparently valid
++ * but that rapidly degrade to invalid, potentially crashing, sets because of
++ * arithmetic inaccuracies when calculations are performed on them. The new
++ * check is to round-trip xy -> XYZ -> xy and then check that the result is
++ * within a small percentage of the original.
++ */
++static int
++png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)
++{
++ int result;
++ png_xy xy_test;
++
++ /* As a side-effect this routine also returns the XYZ endpoints. */
++ result = png_XYZ_from_xy(XYZ, xy);
++ if (result != 0)
++ return result;
++
++ result = png_xy_from_XYZ(&xy_test, XYZ);
++ if (result != 0)
++ return result;
++
++ if (png_colorspace_endpoints_match(xy, &xy_test,
++ 5/*actually, the math is pretty accurate*/) != 0)
++ return 0;
++
++ /* Too much slip */
++ return 1;
++}
++
++/* This is the check going the other way. The XYZ is modified to normalize it
++ * (another side-effect) and the xy chromaticities are returned.
++ */
++static int
++png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ)
++{
++ int result;
++ png_XYZ XYZtemp;
++
++ result = png_XYZ_normalize(XYZ);
++ if (result != 0)
++ return result;
++
++ result = png_xy_from_XYZ(xy, XYZ);
++ if (result != 0)
++ return result;
++
++ XYZtemp = *XYZ;
++ return png_colorspace_check_xy(&XYZtemp, xy);
++}
++
++/* Used to check for an endpoint match against sRGB */
++static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */
++{
++ /* color x y */
++ /* red */ 64000, 33000,
++ /* green */ 30000, 60000,
++ /* blue */ 15000, 6000,
++ /* white */ 31270, 32900
++};
++
++static int
++png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,
++ int preferred)
++{
++ if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
++ return 0;
++
++ /* The consistency check is performed on the chromaticities; this factors out
++ * variations because of the normalization (or not) of the end point Y
++ * values.
++ */
++ if (preferred < 2 &&
++ (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
++ {
++ /* The end points must be reasonably close to any we already have. The
++ * following allows an error of up to +/-.001
++ */
++ if (png_colorspace_endpoints_match(xy, &colorspace->end_points_xy,
++ 100) == 0)
++ {
++ colorspace->flags |= PNG_COLORSPACE_INVALID;
++ png_benign_error(png_ptr, "inconsistent chromaticities");
++ return 0; /* failed */
++ }
++
++ /* Only overwrite with preferred values */
++ if (preferred == 0)
++ return 1; /* ok, but no change */
++ }
++
++ colorspace->end_points_xy = *xy;
++ colorspace->end_points_XYZ = *XYZ;
++ colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS;
++
++ /* The end points are normally quoted to two decimal digits, so allow +/-0.01
++ * on this test.
++ */
++ if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000) != 0)
++ colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;
++
++ else
++ colorspace->flags &= PNG_COLORSPACE_CANCEL(
++ PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
++
++ return 2; /* ok and changed */
++}
+
+ int /* PRIVATE */
+-png_check_cHRM_fixed(png_structp png_ptr,
+- png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
+- png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
+- png_fixed_point blue_x, png_fixed_point blue_y)
++png_colorspace_set_chromaticities(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, const png_xy *xy, int preferred)
+ {
+- int ret = 1;
+- unsigned long xy_hi,xy_lo,yx_hi,yx_lo;
+-
+- png_debug(1, "in function png_check_cHRM_fixed");
+-
+- if (png_ptr == NULL)
++ /* We must check the end points to ensure they are reasonable - in the past
++ * color management systems have crashed as a result of getting bogus
++ * colorant values, while this isn't the fault of libpng it is the
++ * responsibility of libpng because PNG carries the bomb and libpng is in a
++ * position to protect against it.
++ */
++ png_XYZ XYZ;
++
++ switch (png_colorspace_check_xy(&XYZ, xy))
++ {
++ case 0: /* success */
++ return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
++ preferred);
++
++ case 1:
++ /* We can't invert the chromaticities so we can't produce value XYZ
++ * values. Likely as not a color management system will fail too.
++ */
++ colorspace->flags |= PNG_COLORSPACE_INVALID;
++ png_benign_error(png_ptr, "invalid chromaticities");
++ break;
++
++ default:
++ /* libpng is broken; this should be a warning but if it happens we
++ * want error reports so for the moment it is an error.
++ */
++ colorspace->flags |= PNG_COLORSPACE_INVALID;
++ png_error(png_ptr, "internal error checking chromaticities");
++ break;
++ }
++
++ return 0; /* failed */
++}
++
++int /* PRIVATE */
++png_colorspace_set_endpoints(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
++{
++ png_XYZ XYZ = *XYZ_in;
++ png_xy xy;
++
++ switch (png_colorspace_check_XYZ(&xy, &XYZ))
++ {
++ case 0:
++ return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
++ preferred);
++
++ case 1:
++ /* End points are invalid. */
++ colorspace->flags |= PNG_COLORSPACE_INVALID;
++ png_benign_error(png_ptr, "invalid end points");
++ break;
++
++ default:
++ colorspace->flags |= PNG_COLORSPACE_INVALID;
++ png_error(png_ptr, "internal error checking chromaticities");
++ break;
++ }
++
++ return 0; /* failed */
++}
++
++#if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED)
++/* Error message generation */
++static char
++png_icc_tag_char(png_uint_32 byte)
++{
++ byte &= 0xff;
++ if (byte >= 32 && byte <= 126)
++ return (char)byte;
++ else
++ return '?';
++}
++
++static void
++png_icc_tag_name(char *name, png_uint_32 tag)
++{
++ name[0] = '\'';
++ name[1] = png_icc_tag_char(tag >> 24);
++ name[2] = png_icc_tag_char(tag >> 16);
++ name[3] = png_icc_tag_char(tag >> 8);
++ name[4] = png_icc_tag_char(tag );
++ name[5] = '\'';
++}
++
++static int
++is_ICC_signature_char(png_alloc_size_t it)
++{
++ return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) ||
++ (it >= 97 && it <= 122);
++}
++
++static int
++is_ICC_signature(png_alloc_size_t it)
++{
++ return is_ICC_signature_char(it >> 24) /* checks all the top bits */ &&
++ is_ICC_signature_char((it >> 16) & 0xff) &&
++ is_ICC_signature_char((it >> 8) & 0xff) &&
++ is_ICC_signature_char(it & 0xff);
++}
++
++static int
++png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
++ png_const_charp name, png_alloc_size_t value, png_const_charp reason)
++{
++ size_t pos;
++ char message[196]; /* see below for calculation */
++
++ if (colorspace != NULL)
++ colorspace->flags |= PNG_COLORSPACE_INVALID;
++
++ pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */
++ pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */
++ pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */
++ if (is_ICC_signature(value) != 0)
++ {
++ /* So 'value' is at most 4 bytes and the following cast is safe */
++ png_icc_tag_name(message+pos, (png_uint_32)value);
++ pos += 6; /* total +8; less than the else clause */
++ message[pos++] = ':';
++ message[pos++] = ' ';
++ }
++# ifdef PNG_WARNINGS_SUPPORTED
++ else
++ {
++ char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/
++
++ pos = png_safecat(message, (sizeof message), pos,
++ png_format_number(number, number+(sizeof number),
++ PNG_NUMBER_FORMAT_x, value));
++ pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/
++ }
++# endif
++ /* The 'reason' is an arbitrary message, allow +79 maximum 195 */
++ pos = png_safecat(message, (sizeof message), pos, reason);
++ PNG_UNUSED(pos)
++
++ /* This is recoverable, but make it unconditionally an app_error on write to
++ * avoid writing invalid ICC profiles into PNG files (i.e., we handle them
++ * on read, with a warning, but on write unless the app turns off
++ * application errors the PNG won't be written.)
++ */
++ png_chunk_report(png_ptr, message,
++ (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR);
++
++ return 0;
++}
++#endif /* sRGB || iCCP */
++
++#ifdef PNG_sRGB_SUPPORTED
++int /* PRIVATE */
++png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
++ int intent)
++{
++ /* sRGB sets known gamma, end points and (from the chunk) intent. */
++ /* IMPORTANT: these are not necessarily the values found in an ICC profile
++ * because ICC profiles store values adapted to a D50 environment; it is
++ * expected that the ICC profile mediaWhitePointTag will be D50; see the
++ * checks and code elsewhere to understand this better.
++ *
++ * These XYZ values, which are accurate to 5dp, produce rgb to gray
++ * coefficients of (6968,23435,2366), which are reduced (because they add up
++ * to 32769 not 32768) to (6968,23434,2366). These are the values that
++ * libpng has traditionally used (and are the best values given the 15bit
++ * algorithm used by the rgb to gray code.)
++ */
++ static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */
++ {
++ /* color X Y Z */
++ /* red */ 41239, 21264, 1933,
++ /* green */ 35758, 71517, 11919,
++ /* blue */ 18048, 7219, 95053
++ };
++
++ /* Do nothing if the colorspace is already invalidated. */
++ if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
+ return 0;
+
+- /* (x,y,z) values are first limited to 0..100000 (PNG_FP_1), the white
+- * y must also be greater than 0. To test for the upper limit calculate
+- * (PNG_FP_1-y) - x must be <= to this for z to be >= 0 (and the expression
+- * cannot overflow.) At this point we know x and y are >= 0 and (x+y) is
+- * <= PNG_FP_1. The previous test on PNG_MAX_UINT_31 is removed because it
+- * pointless (and it produces compiler warnings!)
++ /* Check the intent, then check for existing settings. It is valid for the
++ * PNG file to have cHRM or gAMA chunks along with sRGB, but the values must
++ * be consistent with the correct values. If, however, this function is
++ * called below because an iCCP chunk matches sRGB then it is quite
++ * conceivable that an older app recorded incorrect gAMA and cHRM because of
++ * an incorrect calculation based on the values in the profile - this does
++ * *not* invalidate the profile (though it still produces an error, which can
++ * be ignored.)
+ */
+- if (white_x < 0 || white_y <= 0 ||
+- red_x < 0 || red_y < 0 ||
+- green_x < 0 || green_y < 0 ||
+- blue_x < 0 || blue_y < 0)
++ if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST)
++ return png_icc_profile_error(png_ptr, colorspace, "sRGB",
++ (unsigned)intent, "invalid sRGB rendering intent");
++
++ if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 &&
++ colorspace->rendering_intent != intent)
++ return png_icc_profile_error(png_ptr, colorspace, "sRGB",
++ (unsigned)intent, "inconsistent rendering intents");
++
++ if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0)
+ {
+- png_warning(png_ptr,
+- "Ignoring attempt to set negative chromaticity value");
+- ret = 0;
++ png_benign_error(png_ptr, "duplicate sRGB information ignored");
++ return 0;
+ }
+- /* And (x+y) must be <= PNG_FP_1 (so z is >= 0) */
+- if (white_x > PNG_FP_1 - white_y)
++
++ /* If the standard sRGB cHRM chunk does not match the one from the PNG file
++ * warn but overwrite the value with the correct one.
++ */
++ if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
++ !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
++ 100))
++ png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
++ PNG_CHUNK_ERROR);
++
++ /* This check is just done for the error reporting - the routine always
++ * returns true when the 'from' argument corresponds to sRGB (2).
++ */
++ (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
++ 2/*from sRGB*/);
++
++ /* intent: bugs in GCC force 'int' to be used as the parameter type. */
++ colorspace->rendering_intent = (png_uint_16)intent;
++ colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT;
++
++ /* endpoints */
++ colorspace->end_points_xy = sRGB_xy;
++ colorspace->end_points_XYZ = sRGB_XYZ;
++ colorspace->flags |=
++ (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
++
++ /* gamma */
++ colorspace->gamma = PNG_GAMMA_sRGB_INVERSE;
++ colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA;
++
++ /* Finally record that we have an sRGB profile */
++ colorspace->flags |=
++ (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB);
++
++ return 1; /* set */
++}
++#endif /* sRGB */
++
++#ifdef PNG_iCCP_SUPPORTED
++/* Encoded value of D50 as an ICC XYZNumber. From the ICC 2010 spec the value
++ * is XYZ(0.9642,1.0,0.8249), which scales to:
++ *
++ * (63189.8112, 65536, 54060.6464)
++ */
++static const png_byte D50_nCIEXYZ[12] =
++ { 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d };
++
++int /* PRIVATE */
++png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,
++ png_const_charp name, png_uint_32 profile_length)
++{
++ if (profile_length < 132)
++ return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
++ "too short");
++
++ return 1;
++}
++
++int /* PRIVATE */
++png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
++ png_const_charp name, png_uint_32 profile_length,
++ png_const_bytep profile/* first 132 bytes only */, int color_type)
++{
++ png_uint_32 temp;
++
++ /* Length check; this cannot be ignored in this code because profile_length
++ * is used later to check the tag table, so even if the profile seems over
++ * long profile_length from the caller must be correct. The caller can fix
++ * this up on read or write by just passing in the profile header length.
++ */
++ temp = png_get_uint_32(profile);
++ if (temp != profile_length)
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "length does not match profile");
++
++ temp = (png_uint_32) (*(profile+8));
++ if (temp > 3 && (profile_length & 3))
++ return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
++ "invalid length");
++
++ temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */
++ if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */
++ profile_length < 132+12*temp) /* truncated tag table */
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "tag count too large");
++
++ /* The 'intent' must be valid or we can't store it, ICC limits the intent to
++ * 16 bits.
++ */
++ temp = png_get_uint_32(profile+64);
++ if (temp >= 0xffff) /* The ICC limit */
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "invalid rendering intent");
++
++ /* This is just a warning because the profile may be valid in future
++ * versions.
++ */
++ if (temp >= PNG_sRGB_INTENT_LAST)
++ (void)png_icc_profile_error(png_ptr, NULL, name, temp,
++ "intent outside defined range");
++
++ /* At this point the tag table can't be checked because it hasn't necessarily
++ * been loaded; however, various header fields can be checked. These checks
++ * are for values permitted by the PNG spec in an ICC profile; the PNG spec
++ * restricts the profiles that can be passed in an iCCP chunk (they must be
++ * appropriate to processing PNG data!)
++ */
++
++ /* Data checks (could be skipped). These checks must be independent of the
++ * version number; however, the version number doesn't accomodate changes in
++ * the header fields (just the known tags and the interpretation of the
++ * data.)
++ */
++ temp = png_get_uint_32(profile+36); /* signature 'ascp' */
++ if (temp != 0x61637370)
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "invalid signature");
++
++ /* Currently the PCS illuminant/adopted white point (the computational
++ * white point) are required to be D50,
++ * however the profile contains a record of the illuminant so perhaps ICC
++ * expects to be able to change this in the future (despite the rationale in
++ * the introduction for using a fixed PCS adopted white.) Consequently the
++ * following is just a warning.
++ */
++ if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0)
++ (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,
++ "PCS illuminant is not D50");
++
++ /* The PNG spec requires this:
++ * "If the iCCP chunk is present, the image samples conform to the colour
++ * space represented by the embedded ICC profile as defined by the
++ * International Color Consortium [ICC]. The colour space of the ICC profile
++ * shall be an RGB colour space for colour images (PNG colour types 2, 3, and
++ * 6), or a greyscale colour space for greyscale images (PNG colour types 0
++ * and 4)."
++ *
++ * This checking code ensures the embedded profile (on either read or write)
++ * conforms to the specification requirements. Notice that an ICC 'gray'
++ * color-space profile contains the information to transform the monochrome
++ * data to XYZ or L*a*b (according to which PCS the profile uses) and this
++ * should be used in preference to the standard libpng K channel replication
++ * into R, G and B channels.
++ *
++ * Previously it was suggested that an RGB profile on grayscale data could be
++ * handled. However it it is clear that using an RGB profile in this context
++ * must be an error - there is no specification of what it means. Thus it is
++ * almost certainly more correct to ignore the profile.
++ */
++ temp = png_get_uint_32(profile+16); /* data colour space field */
++ switch (temp)
+ {
+- png_warning(png_ptr, "Invalid cHRM white point");
+- ret = 0;
++ case 0x52474220: /* 'RGB ' */
++ if ((color_type & PNG_COLOR_MASK_COLOR) == 0)
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "RGB color space not permitted on grayscale PNG");
++ break;
++
++ case 0x47524159: /* 'GRAY' */
++ if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "Gray color space not permitted on RGB PNG");
++ break;
++
++ default:
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "invalid ICC profile color space");
+ }
+
+- if (red_x > PNG_FP_1 - red_y)
++ /* It is up to the application to check that the profile class matches the
++ * application requirements; the spec provides no guidance, but it's pretty
++ * weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer
++ * ('prtr') or 'spac' (for generic color spaces). Issue a warning in these
++ * cases. Issue an error for device link or abstract profiles - these don't
++ * contain the records necessary to transform the color-space to anything
++ * other than the target device (and not even that for an abstract profile).
++ * Profiles of these classes may not be embedded in images.
++ */
++ temp = png_get_uint_32(profile+12); /* profile/device class */
++ switch (temp)
+ {
+- png_warning(png_ptr, "Invalid cHRM red point");
+- ret = 0;
++ case 0x73636E72: /* 'scnr' */
++ case 0x6D6E7472: /* 'mntr' */
++ case 0x70727472: /* 'prtr' */
++ case 0x73706163: /* 'spac' */
++ /* All supported */
++ break;
++
++ case 0x61627374: /* 'abst' */
++ /* May not be embedded in an image */
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "invalid embedded Abstract ICC profile");
++
++ case 0x6C696E6B: /* 'link' */
++ /* DeviceLink profiles cannot be interpreted in a non-device specific
++ * fashion, if an app uses the AToB0Tag in the profile the results are
++ * undefined unless the result is sent to the intended device,
++ * therefore a DeviceLink profile should not be found embedded in a
++ * PNG.
++ */
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "unexpected DeviceLink ICC profile class");
++
++ case 0x6E6D636C: /* 'nmcl' */
++ /* A NamedColor profile is also device specific, however it doesn't
++ * contain an AToB0 tag that is open to misinterpretation. Almost
++ * certainly it will fail the tests below.
++ */
++ (void)png_icc_profile_error(png_ptr, NULL, name, temp,
++ "unexpected NamedColor ICC profile class");
++ break;
++
++ default:
++ /* To allow for future enhancements to the profile accept unrecognized
++ * profile classes with a warning, these then hit the test below on the
++ * tag content to ensure they are backward compatible with one of the
++ * understood profiles.
++ */
++ (void)png_icc_profile_error(png_ptr, NULL, name, temp,
++ "unrecognized ICC profile class");
++ break;
+ }
+
+- if (green_x > PNG_FP_1 - green_y)
++ /* For any profile other than a device link one the PCS must be encoded
++ * either in XYZ or Lab.
++ */
++ temp = png_get_uint_32(profile+20);
++ switch (temp)
+ {
+- png_warning(png_ptr, "Invalid cHRM green point");
+- ret = 0;
++ case 0x58595A20: /* 'XYZ ' */
++ case 0x4C616220: /* 'Lab ' */
++ break;
++
++ default:
++ return png_icc_profile_error(png_ptr, colorspace, name, temp,
++ "unexpected ICC PCS encoding");
+ }
+
+- if (blue_x > PNG_FP_1 - blue_y)
++ return 1;
++}
++
++int /* PRIVATE */
++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_uint_32 tag_count = png_get_uint_32(profile+128);
++ png_uint_32 itag;
++ png_const_bytep tag = profile+132; /* The first tag */
++
++ /* First scan all the tags in the table and add bits to the icc_info value
++ * (temporarily in 'tags').
++ */
++ for (itag=0; itag < tag_count; ++itag, tag += 12)
+ {
+- png_warning(png_ptr, "Invalid cHRM blue point");
+- ret = 0;
++ png_uint_32 tag_id = png_get_uint_32(tag+0);
++ png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */
++ png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */
++
++ /* The ICC specification does not exclude zero length tags, therefore the
++ * start might actually be anywhere if there is no data, but this would be
++ * a clear abuse of the intent of the standard so the start is checked for
++ * being in range. All defined tag types have an 8 byte header - a 4 byte
++ * type signature then 0.
++ */
++ if ((tag_start & 3) != 0)
++ {
++ /* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is
++ * only a warning here because libpng does not care about the
++ * alignment.
++ */
++ (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
++ "ICC profile tag start not a multiple of 4");
++ }
++
++ /* This is a hard error; potentially it can cause read outside the
++ * profile.
++ */
++ if (tag_start > profile_length || tag_length > profile_length - tag_start)
++ return png_icc_profile_error(png_ptr, colorspace, name, tag_id,
++ "ICC profile tag outside profile");
+ }
+
+- png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);
+- png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);
+-
+- if (xy_hi == yx_hi && xy_lo == yx_lo)
++ return 1; /* success, maybe with warnings */
++}
++
++#if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0
++/* Information about the known ICC sRGB profiles */
++static const struct
++{
++ png_uint_32 adler, crc, length;
++ png_uint_32 md5[4];
++ png_byte have_md5;
++ png_byte is_broken;
++ png_uint_16 intent;
++
++# define PNG_MD5(a,b,c,d) { a, b, c, d }, (a!=0)||(b!=0)||(c!=0)||(d!=0)
++# define PNG_ICC_CHECKSUM(adler, crc, md5, intent, broke, date, length, fname)\
++ { adler, crc, length, md5, broke, intent },
++
++} png_sRGB_checks[] =
++{
++ /* This data comes from contrib/tools/checksum-icc run on downloads of
++ * all four ICC sRGB profiles from www.color.org.
++ */
++ /* adler32, crc32, MD5[4], intent, date, length, file-name */
++ PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9,
++ PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0,
++ "2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc")
++
++ /* ICC sRGB v2 perceptual no black-compensation: */
++ PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21,
++ PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0,
++ "2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc")
++
++ PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae,
++ PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0,
++ "2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc")
++
++ /* ICC sRGB v4 perceptual */
++ PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812,
++ PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0,
++ "2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc")
++
++ /* The following profiles have no known MD5 checksum. If there is a match
++ * on the (empty) MD5 the other fields are used to attempt a match and
++ * a warning is produced. The first two of these profiles have a 'cprt' tag
++ * which suggests that they were also made by Hewlett Packard.
++ */
++ PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce,
++ PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0,
++ "2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc")
++
++ /* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not
++ * match the D50 PCS illuminant in the header (it is in fact the D65 values,
++ * so the white point is recorded as the un-adapted value.) The profiles
++ * below only differ in one byte - the intent - and are basically the same as
++ * the previous profile except for the mediaWhitePointTag error and a missing
++ * chromaticAdaptationTag.
++ */
++ PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552,
++ PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/,
++ "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual")
++
++ PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d,
++ PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/,
++ "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative")
++};
++
++static int
++png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
++ png_const_bytep profile, uLong adler)
++{
++ /* The quick check is to verify just the MD5 signature and trust the
++ * rest of the data. Because the profile has already been verified for
++ * correctness this is safe. png_colorspace_set_sRGB will check the 'intent'
++ * field too, so if the profile has been edited with an intent not defined
++ * by sRGB (but maybe defined by a later ICC specification) the read of
++ * the profile will fail at that point.
++ */
++
++ png_uint_32 length = 0;
++ png_uint_32 intent = 0x10000; /* invalid */
++#if PNG_sRGB_PROFILE_CHECKS > 1
++ uLong crc = 0; /* the value for 0 length data */
++#endif
++ unsigned int i;
++
++#ifdef PNG_SET_OPTION_SUPPORTED
++ /* First see if PNG_SKIP_sRGB_CHECK_PROFILE has been set to "on" */
++ if (((png_ptr->options >> PNG_SKIP_sRGB_CHECK_PROFILE) & 3) ==
++ PNG_OPTION_ON)
++ return 0;
++#endif
++
++ for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i)
+ {
+- png_warning(png_ptr,
+- "Ignoring attempt to set cHRM RGB triangle with zero area");
+- ret = 0;
++ if (png_get_uint_32(profile+84) == png_sRGB_checks[i].md5[0] &&
++ png_get_uint_32(profile+88) == png_sRGB_checks[i].md5[1] &&
++ png_get_uint_32(profile+92) == png_sRGB_checks[i].md5[2] &&
++ png_get_uint_32(profile+96) == png_sRGB_checks[i].md5[3])
++ {
++ /* This may be one of the old HP profiles without an MD5, in that
++ * case we can only use the length and Adler32 (note that these
++ * are not used by default if there is an MD5!)
++ */
++# if PNG_sRGB_PROFILE_CHECKS == 0
++ if (png_sRGB_checks[i].have_md5 != 0)
++ return 1+png_sRGB_checks[i].is_broken;
++# endif
++
++ /* Profile is unsigned or more checks have been configured in. */
++ if (length == 0)
++ {
++ length = png_get_uint_32(profile);
++ intent = png_get_uint_32(profile+64);
++ }
++
++ /* Length *and* intent must match */
++ if (length == png_sRGB_checks[i].length &&
++ intent == png_sRGB_checks[i].intent)
++ {
++ /* Now calculate the adler32 if not done already. */
++ if (adler == 0)
++ {
++ adler = adler32(0, NULL, 0);
++ adler = adler32(adler, profile, length);
++ }
++
++ if (adler == png_sRGB_checks[i].adler)
++ {
++ /* These basic checks suggest that the data has not been
++ * modified, but if the check level is more than 1 perform
++ * our own crc32 checksum on the data.
++ */
++# if PNG_sRGB_PROFILE_CHECKS > 1
++ if (crc == 0)
++ {
++ crc = crc32(0, NULL, 0);
++ crc = crc32(crc, profile, length);
++ }
++
++ /* So this check must pass for the 'return' below to happen.
++ */
++ if (crc == png_sRGB_checks[i].crc)
++# endif
++ {
++ if (png_sRGB_checks[i].is_broken != 0)
++ {
++ /* These profiles are known to have bad data that may cause
++ * problems if they are used, therefore attempt to
++ * discourage their use, skip the 'have_md5' warning below,
++ * which is made irrelevant by this error.
++ */
++ png_chunk_report(png_ptr, "known incorrect sRGB profile",
++ PNG_CHUNK_ERROR);
++ }
++
++ /* Warn that this being done; this isn't even an error since
++ * the profile is perfectly valid, but it would be nice if
++ * people used the up-to-date ones.
++ */
++ else if (png_sRGB_checks[i].have_md5 == 0)
++ {
++ png_chunk_report(png_ptr, "out-of-date sRGB profile with"
++ " no signature",
++ PNG_CHUNK_WARNING);
++ }
++
++ return 1+png_sRGB_checks[i].is_broken;
++ }
++ }
++
++# if PNG_sRGB_PROFILE_CHECKS > 0
++ /* The signature matched, but the profile had been changed in some
++ * way. This probably indicates a data error or uninformed hacking.
++ * Fall through to "no match".
++ */
++ png_chunk_report(png_ptr, "Not recognizing known sRGB profile that"
++ " has been edited",
++ PNG_CHUNK_WARNING);
++ break;
++# endif
++ }
++ }
+ }
+
+- return ret;
++ return 0; /* no match */
+ }
+-# endif /* PNG_CHECK_cHRM_SUPPORTED */
+-
++#endif
++
++#ifdef PNG_sRGB_SUPPORTED
+ void /* PRIVATE */
+-png_check_IHDR(png_structp png_ptr,
++png_icc_set_sRGB(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, png_const_bytep profile, uLong adler)
++{
++ /* Is this profile one of the known ICC sRGB profiles? If it is, just set
++ * the sRGB information.
++ */
++#if PNG_sRGB_PROFILE_CHECKS >= 0
++ if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
++#endif
++ (void)png_colorspace_set_sRGB(png_ptr, colorspace,
++ (int)/*already checked*/png_get_uint_32(profile+64));
++}
++#endif /* READ_sRGB */
++
++int /* PRIVATE */
++png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
++ png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,
++ int color_type)
++{
++ if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
++ return 0;
++
++ if (png_icc_check_length(png_ptr, colorspace, name, profile_length) != 0 &&
++ png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
++ color_type) != 0 &&
++ png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
++ profile) != 0)
++ {
++# ifdef PNG_sRGB_SUPPORTED
++ /* If no sRGB support, don't try storing sRGB information */
++ png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
++# endif
++ return 1;
++ }
++
++ /* Failure case */
++ return 0;
++}
++#endif /* iCCP */
++
++#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
++void /* PRIVATE */
++png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
++{
++ /* Set the rgb_to_gray coefficients from the colorspace. */
++ if (png_ptr->rgb_to_gray_coefficients_set == 0 &&
++ (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
++ {
++ /* png_set_background has not been called, get the coefficients from the Y
++ * values of the colorspace colorants.
++ */
++ png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
++ png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
++ png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
++ png_fixed_point total = r+g+b;
++
++ if (total > 0 &&
++ r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&
++ g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&
++ b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&
++ r+g+b <= 32769)
++ {
++ /* We allow 0 coefficients here. r+g+b may be 32769 if two or
++ * all of the coefficients were rounded up. Handle this by
++ * reducing the *largest* coefficient by 1; this matches the
++ * approach used for the default coefficients in pngrtran.c
++ */
++ int add = 0;
++
++ if (r+g+b > 32768)
++ add = -1;
++ else if (r+g+b < 32768)
++ add = 1;
++
++ if (add != 0)
++ {
++ if (g >= r && g >= b)
++ g += add;
++ else if (r >= g && r >= b)
++ r += add;
++ else
++ b += add;
++ }
++
++ /* Check for an internal error. */
++ if (r+g+b != 32768)
++ png_error(png_ptr,
++ "internal error handling cHRM coefficients");
++
++ else
++ {
++ png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r;
++ png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
++ }
++ }
++
++ /* This is a png_error at present even though it could be ignored -
++ * it should never happen, but it is important that if it does, the
++ * bug is fixed.
++ */
++ else
++ png_error(png_ptr, "internal error handling cHRM->XYZ");
++ }
++}
++#endif
++
++#endif /* COLORSPACE */
++
++#ifdef __GNUC__
++/* This exists solely to work round a warning from GNU C. */
++static int /* PRIVATE */
++png_gt(size_t a, size_t b)
++{
++ return a > b;
++}
++#else
++# define png_gt(a,b) ((a) > (b))
++#endif
++
++void /* PRIVATE */
++png_check_IHDR(png_const_structrp png_ptr,
+ png_uint_32 width, png_uint_32 height, int bit_depth,
+ int color_type, int interlace_type, int compression_type,
+ int filter_type)
+@@ -840,53 +2514,68 @@
+ png_warning(png_ptr, "Image width is zero in IHDR");
+ error = 1;
+ }
++ else if (width > PNG_UINT_31_MAX)
++ {
++ png_warning(png_ptr, "Invalid image width in IHDR");
++ error = 1;
++ }
++
++ else if (png_gt(width,
++ (PNG_SIZE_MAX >> 3) /* 8-byte RGBA pixels */
++ - 48 /* big_row_buf hack */
++ - 1 /* filter byte */
++ - 7*8 /* rounding width to multiple of 8 pix */
++ - 8)) /* extra max_pixel_depth pad */
++ {
++ /* The size of the row must be within the limits of this architecture.
++ * Because the read code can perform arbitrary transformations the
++ * maximum size is checked here. Because the code in png_read_start_row
++ * adds extra space "for safety's sake" in several places a conservative
++ * limit is used here.
++ *
++ * NOTE: it would be far better to check the size that is actually used,
++ * but the effect in the real world is minor and the changes are more
++ * extensive, therefore much more dangerous and much more difficult to
++ * write in a way that avoids compiler warnings.
++ */
++ png_warning(png_ptr, "Image width is too large for this architecture");
++ error = 1;
++ }
++ else
++ {
++# ifdef PNG_SET_USER_LIMITS_SUPPORTED
++ if (width > png_ptr->user_width_max)
++# else
++ if (width > PNG_USER_WIDTH_MAX)
++# endif
++ {
++ png_warning(png_ptr, "Image width exceeds user limit in IHDR");
++ error = 1;
++ }
++ }
+
+ if (height == 0)
+ {
+ png_warning(png_ptr, "Image height is zero in IHDR");
+ error = 1;
+ }
+-
+-# ifdef PNG_SET_USER_LIMITS_SUPPORTED
+- if (width > png_ptr->user_width_max)
+-
+-# else
+- if (width > PNG_USER_WIDTH_MAX)
+-# endif
+- {
+- png_warning(png_ptr, "Image width exceeds user limit in IHDR");
+- error = 1;
+- }
+-
+-# ifdef PNG_SET_USER_LIMITS_SUPPORTED
+- if (height > png_ptr->user_height_max)
+-# else
+- if (height > PNG_USER_HEIGHT_MAX)
+-# endif
+- {
+- png_warning(png_ptr, "Image height exceeds user limit in IHDR");
+- error = 1;
+- }
+-
+- if (width > PNG_UINT_31_MAX)
+- {
+- png_warning(png_ptr, "Invalid image width in IHDR");
+- error = 1;
+- }
+-
+- if (height > PNG_UINT_31_MAX)
++ else if (height > PNG_UINT_31_MAX)
+ {
+ png_warning(png_ptr, "Invalid image height in IHDR");
+ error = 1;
+ }
+-
+- if (width > (PNG_UINT_32_MAX
+- >> 3) /* 8-byte RGBA pixels */
+- - 48 /* bigrowbuf hack */
+- - 1 /* filter byte */
+- - 7*8 /* rounding of width to multiple of 8 pixels */
+- - 8) /* extra max_pixel_depth pad */
+- png_warning(png_ptr, "Width is too large for libpng to process pixels");
++ else
++ {
++# ifdef PNG_SET_USER_LIMITS_SUPPORTED
++ if (height > png_ptr->user_height_max)
++# else
++ if (height > PNG_USER_HEIGHT_MAX)
++# endif
++ {
++ png_warning(png_ptr, "Image height exceeds user limit in IHDR");
++ error = 1;
++ }
++ }
+
+ /* Check other values */
+ if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
+@@ -934,13 +2623,13 @@
+ * 4. The filter_method is 64 and
+ * 5. The color_type is RGB or RGBA
+ */
+- if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&
+- png_ptr->mng_features_permitted)
++ if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 &&
++ png_ptr->mng_features_permitted != 0)
+ png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
+
+ if (filter_type != PNG_FILTER_TYPE_BASE)
+ {
+- if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
++ if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
+ (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
+ ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
+ (color_type == PNG_COLOR_TYPE_RGB ||
+@@ -950,7 +2639,7 @@
+ error = 1;
+ }
+
+- if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
++ if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0)
+ {
+ png_warning(png_ptr, "Invalid filter method in IHDR");
+ error = 1;
+@@ -1010,7 +2699,7 @@
+ switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
+ {
+ case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
+- if (state & PNG_FP_SAW_ANY)
++ if ((state & PNG_FP_SAW_ANY) != 0)
+ goto PNG_FP_End; /* not a part of the number */
+
+ png_fp_add(state, type);
+@@ -1018,10 +2707,10 @@
+
+ case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
+ /* Ok as trailer, ok as lead of fraction. */
+- if (state & PNG_FP_SAW_DOT) /* two dots */
++ if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */
+ goto PNG_FP_End;
+
+- else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */
++ else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */
+ png_fp_add(state, type);
+
+ else
+@@ -1030,7 +2719,7 @@
+ break;
+
+ case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
+- if (state & PNG_FP_SAW_DOT) /* delayed fraction */
++ if ((state & PNG_FP_SAW_DOT) != 0) /* delayed fraction */
+ png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
+
+ png_fp_add(state, type | PNG_FP_WAS_VALID);
+@@ -1068,7 +2757,7 @@
+ break;
+
+ case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
+- if (state & PNG_FP_SAW_ANY)
++ if ((state & PNG_FP_SAW_ANY) != 0)
+ goto PNG_FP_End; /* not a part of the number */
+
+ png_fp_add(state, PNG_FP_SAW_SIGN);
+@@ -1111,15 +2800,15 @@
+ int state=0;
+ png_size_t char_index=0;
+
+- if (png_check_fp_number(string, size, &state, &char_index) &&
++ if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
+ (char_index == size || string[char_index] == 0))
+ return state /* must be non-zero - see above */;
+
+ return 0; /* i.e. fail */
+ }
+-#endif /* pCAL or sCAL */
+-
+-#ifdef PNG_READ_sCAL_SUPPORTED
++#endif /* pCAL || sCAL */
++
++#ifdef PNG_sCAL_SUPPORTED
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ /* Utility used below - a simple accurate power of ten from an integral
+ * exponent.
+@@ -1151,7 +2840,7 @@
+ }
+ while (power > 0);
+
+- if (recip) d = 1/d;
++ if (recip != 0) d = 1/d;
+ }
+ /* else power is 0 and d is 1 */
+
+@@ -1162,7 +2851,7 @@
+ * precision.
+ */
+ void /* PRIVATE */
+-png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
++png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
+ double fp, unsigned int precision)
+ {
+ /* We use standard functions from math.h, but not printf because
+@@ -1365,8 +3054,9 @@
+
+ if (exp_b10 != (-1))
+ {
+- if (exp_b10 == 0) *ascii++ = 46, --size; /* counted
+- above */
++ if (exp_b10 == 0)
++ *ascii++ = 46, --size; /* counted above */
++
+ --exp_b10;
+ }
+ *ascii++ = (char)(48 + (int)d), ++cdigits;
+@@ -1411,18 +3101,30 @@
+ size -= cdigits;
+
+ *ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision */
+- if (exp_b10 < 0)
++
++ /* The following use of an unsigned temporary avoids ambiguities in
++ * the signed arithmetic on exp_b10 and permits GCC at least to do
++ * better optimization.
++ */
+ {
+- *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
+- exp_b10 = -exp_b10;
+- }
+-
+- cdigits = 0;
+-
+- while (exp_b10 > 0)
+- {
+- exponent[cdigits++] = (char)(48 + exp_b10 % 10);
+- exp_b10 /= 10;
++ unsigned int uexp_b10;
++
++ if (exp_b10 < 0)
++ {
++ *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
++ uexp_b10 = -exp_b10;
++ }
++
++ else
++ uexp_b10 = exp_b10;
++
++ cdigits = 0;
++
++ while (uexp_b10 > 0)
++ {
++ exponent[cdigits++] = (char)(48 + uexp_b10 % 10);
++ uexp_b10 /= 10;
++ }
+ }
+
+ /* Need another size check here for the exponent digits, so
+@@ -1464,8 +3166,8 @@
+ /* Function to format a fixed point value in ASCII.
+ */
+ void /* PRIVATE */
+-png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size,
+- png_fixed_point fp)
++png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,
++ png_size_t size, png_fixed_point fp)
+ {
+ /* Require space for 10 decimal digits, a decimal point, a minus sign and a
+ * trailing \0, 13 characters:
+@@ -1480,7 +3182,7 @@
+ else
+ num = fp;
+
+- if (num <= 0x80000000U) /* else overflowed */
++ if (num <= 0x80000000) /* else overflowed */
+ {
+ unsigned int ndigits = 0, first = 16 /* flag value */;
+ char digits[10];
+@@ -1535,21 +3237,30 @@
+ #endif /* READ_SCAL */
+
+ #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
+- !defined(PNG_FIXED_POINT_MACRO_SUPPORTED)
++ !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
++ (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
++ defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
++ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
++ (defined(PNG_sCAL_SUPPORTED) && \
++ defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
+ png_fixed_point
+-png_fixed(png_structp png_ptr, double fp, png_const_charp text)
++png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)
+ {
+ double r = floor(100000 * fp + .5);
+
+ if (r > 2147483647. || r < -2147483648.)
+ png_fixed_error(png_ptr, text);
+
++# ifndef PNG_ERROR_TEXT_SUPPORTED
++ PNG_UNUSED(text)
++# endif
++
+ return (png_fixed_point)r;
+ }
+ #endif
+
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || \
+- defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED)
++#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_COLORSPACE_SUPPORTED) ||\
++ defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
+ /* muldiv functions */
+ /* This API takes signed arguments and rounds the result to the nearest
+ * integer (or, for a fixed point number - the standard argument - to
+@@ -1653,11 +3364,12 @@
+ if (s00 >= (D >> 1))
+ ++result;
+
+- if (negative)
++ if (negative != 0)
+ result = -result;
+
+ /* Check for overflow. */
+- if ((negative && result <= 0) || (!negative && result >= 0))
++ if ((negative != 0 && result <= 0) ||
++ (negative == 0 && result >= 0))
+ {
+ *res = result;
+ return 1;
+@@ -1676,12 +3388,12 @@
+ * result.
+ */
+ png_fixed_point
+-png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times,
++png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times,
+ png_int_32 divisor)
+ {
+ png_fixed_point result;
+
+- if (png_muldiv(&result, a, times, divisor))
++ if (png_muldiv(&result, a, times, divisor) != 0)
+ return result;
+
+ png_warning(png_ptr, "fixed point overflow ignored");
+@@ -1689,7 +3401,7 @@
+ }
+ #endif
+
+-#ifdef PNG_READ_GAMMA_SUPPORTED /* more fixed point functions for gammma */
++#ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */
+ /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
+ png_fixed_point
+ png_reciprocal(png_fixed_point a)
+@@ -1702,34 +3414,48 @@
+ #else
+ png_fixed_point res;
+
+- if (png_muldiv(&res, 100000, 100000, a))
++ if (png_muldiv(&res, 100000, 100000, a) != 0)
+ return res;
+ #endif
+
+ return 0; /* error/overflow */
+ }
+
++/* This is the shared test on whether a gamma value is 'significant' - whether
++ * it is worth doing gamma correction.
++ */
++int /* PRIVATE */
++png_gamma_significant(png_fixed_point gamma_val)
++{
++ return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
++ gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
++}
++#endif
++
++#ifdef PNG_READ_GAMMA_SUPPORTED
++#if defined(PNG_16BIT_SUPPORTED) || !defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
+ /* A local convenience routine. */
+ static png_fixed_point
+ png_product2(png_fixed_point a, png_fixed_point b)
+ {
+ /* The required result is 1/a * 1/b; the following preserves accuracy. */
+-#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
++# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+ double r = a * 1E-5;
+ r *= b;
+ r = floor(r+.5);
+
+ if (r <= 2147483647. && r >= -2147483648.)
+ return (png_fixed_point)r;
+-#else
++# else
+ png_fixed_point res;
+
+- if (png_muldiv(&res, a, b, 100000))
++ if (png_muldiv(&res, a, b, 100000) != 0)
+ return res;
+-#endif
++# endif
+
+ return 0; /* overflow */
+ }
++#endif /* 16BIT || !FLOATING_ARITHMETIC */
+
+ /* The inverse of the above. */
+ png_fixed_point
+@@ -1759,73 +3485,28 @@
+ }
+ #endif /* READ_GAMMA */
+
+-#ifdef PNG_CHECK_cHRM_SUPPORTED
+-/* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2,
+- * 2010: moved from pngset.c) */
+-/*
+- * Multiply two 32-bit numbers, V1 and V2, using 32-bit
+- * arithmetic, to produce a 64-bit result in the HI/LO words.
+- *
+- * A B
+- * x C D
+- * ------
+- * AD || BD
+- * AC || CB || 0
+- *
+- * where A and B are the high and low 16-bit words of V1,
+- * C and D are the 16-bit words of V2, AD is the product of
+- * A and D, and X || Y is (X << 16) + Y.
+-*/
+-
+-void /* PRIVATE */
+-png_64bit_product (long v1, long v2, unsigned long *hi_product,
+- unsigned long *lo_product)
+-{
+- int a, b, c, d;
+- long lo, hi, x, y;
+-
+- a = (v1 >> 16) & 0xffff;
+- b = v1 & 0xffff;
+- c = (v2 >> 16) & 0xffff;
+- d = v2 & 0xffff;
+-
+- lo = b * d; /* BD */
+- x = a * d + c * b; /* AD + CB */
+- y = ((lo >> 16) & 0xffff) + x;
+-
+- lo = (lo & 0xffff) | ((y & 0xffff) << 16);
+- hi = (y >> 16) & 0xffff;
+-
+- hi += a * c; /* AC */
+-
+- *hi_product = (unsigned long)hi;
+- *lo_product = (unsigned long)lo;
+-}
+-#endif /* CHECK_cHRM */
+-
+ #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
+ #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
+ /* Fixed point gamma.
+ *
++ * The code to calculate the tables used below can be found in the shell script
++ * contrib/tools/intgamma.sh
++ *
+ * To calculate gamma this code implements fast log() and exp() calls using only
+ * fixed point arithmetic. This code has sufficient precision for either 8-bit
+ * or 16-bit sample values.
+ *
+ * The tables used here were calculated using simple 'bc' programs, but C double
+- * precision floating point arithmetic would work fine. The programs are given
+- * at the head of each table.
++ * precision floating point arithmetic would work fine.
+ *
+ * 8-bit log table
+ * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
+ * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
+ * mantissa. The numbers are 32-bit fractions.
+ */
+-static png_uint_32
++static const png_uint_32
+ png_8bit_l2[128] =
+ {
+-# if PNG_DO_BC
+- for (i=128;i<256;++i) { .5 - l(i/255)/l(2)*65536*65536; }
+-# endif
+ 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
+ 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
+ 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
+@@ -1848,6 +3529,7 @@
+ 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
+ 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
+ 24347096U, 0U
++
+ #if 0
+ /* The following are the values for 16-bit tables - these work fine for the
+ * 8-bit conversions but produce very slightly larger errors in the 16-bit
+@@ -1869,18 +3551,18 @@
+ #endif
+ };
+
+-PNG_STATIC png_int_32
++static png_int_32
+ png_log8bit(unsigned int x)
+ {
+ unsigned int lg2 = 0;
+ /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
+ * because the log is actually negate that means adding 1. The final
+ * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
+- * input), return 7.99998 for the overflow (log 0) case - so the result is
++ * input), return -1 for the overflow (log 0) case, - so the result is
+ * always at most 19 bits.
+ */
+ if ((x &= 0xff) == 0)
+- return 0xffffffff;
++ return -1;
+
+ if ((x & 0xf0) == 0)
+ lg2 = 4, x <<= 4;
+@@ -1925,14 +3607,15 @@
+ * Zero (257): 0
+ * End (258): 23499
+ */
+-PNG_STATIC png_int_32
++#ifdef PNG_16BIT_SUPPORTED
++static png_int_32
+ png_log16bit(png_uint_32 x)
+ {
+ unsigned int lg2 = 0;
+
+ /* As above, but now the input has 16 bits. */
+ if ((x &= 0xffff) == 0)
+- return 0xffffffff;
++ return -1;
+
+ if ((x & 0xff00) == 0)
+ lg2 = 8, x <<= 8;
+@@ -1975,14 +3658,15 @@
+ /* Safe, because the result can't have more than 20 bits: */
+ return (png_int_32)((lg2 + 2048) >> 12);
+ }
++#endif /* 16BIT */
+
+ /* The 'exp()' case must invert the above, taking a 20-bit fixed point
+ * logarithmic value and returning a 16 or 8-bit number as appropriate. In
+ * each case only the low 16 bits are relevant - the fraction - since the
+ * integer bits (the top 4) simply determine a shift.
+ *
+- * The worst case is the 16-bit distinction between 65535 and 65534, this
+- * requires perhaps spurious accuracty in the decoding of the logarithm to
++ * The worst case is the 16-bit distinction between 65535 and 65534. This
++ * requires perhaps spurious accuracy in the decoding of the logarithm to
+ * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
+ * of getting this accuracy in practice.
+ *
+@@ -1990,12 +3674,9 @@
+ * frational part of the logarithm by using an accurate 32-bit value from the
+ * top four fractional bits then multiplying in the remaining bits.
+ */
+-static png_uint_32
++static const png_uint_32
+ png_32bit_exp[16] =
+ {
+-# if PNG_DO_BC
+- for (i=0;i<16;++i) { .5 + e(-i/16*l(2))*2^32; }
+-# endif
+ /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */
+ 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
+ 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
+@@ -2003,7 +3684,7 @@
+ };
+
+ /* Adjustment table; provided to explain the numbers in the code below. */
+-#if PNG_DO_BC
++#if 0
+ for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
+ 11 44937.64284865548751208448
+ 10 45180.98734845585101160448
+@@ -2019,7 +3700,7 @@
+ 0 45425.85339951654943850496
+ #endif
+
+-PNG_STATIC png_uint_32
++static png_uint_32
+ png_exp(png_fixed_point x)
+ {
+ if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
+@@ -2067,13 +3748,13 @@
+ return 0;
+ }
+
+-PNG_STATIC png_byte
++static png_byte
+ png_exp8bit(png_fixed_point lg2)
+ {
+ /* Get a 32-bit value: */
+ png_uint_32 x = png_exp(lg2);
+
+- /* Convert the 32-bit value to 0..255 by multiplying by 256-1, note that the
++ /* Convert the 32-bit value to 0..255 by multiplying by 256-1. Note that the
+ * second, rounding, step can't overflow because of the first, subtraction,
+ * step.
+ */
+@@ -2081,7 +3762,8 @@
+ return (png_byte)((x + 0x7fffffU) >> 24);
+ }
+
+-PNG_STATIC png_uint_16
++#ifdef PNG_16BIT_SUPPORTED
++static png_uint_16
+ png_exp16bit(png_fixed_point lg2)
+ {
+ /* Get a 32-bit value: */
+@@ -2091,6 +3773,7 @@
+ x -= x >> 16;
+ return (png_uint_16)((x + 32767U) >> 16);
+ }
++#endif /* 16BIT */
+ #endif /* FLOATING_ARITHMETIC */
+
+ png_byte
+@@ -2099,13 +3782,37 @@
+ if (value > 0 && value < 255)
+ {
+ # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+- double r = floor(255*pow(value/255.,gamma_val*.00001)+.5);
++ /* 'value' is unsigned, ANSI-C90 requires the compiler to correctly
++ * convert this to a floating point value. This includes values that
++ * would overflow if 'value' were to be converted to 'int'.
++ *
++ * Apparently GCC, however, does an intermediate conversion to (int)
++ * on some (ARM) but not all (x86) platforms, possibly because of
++ * hardware FP limitations. (E.g. if the hardware conversion always
++ * assumes the integer register contains a signed value.) This results
++ * in ANSI-C undefined behavior for large values.
++ *
++ * Other implementations on the same machine might actually be ANSI-C90
++ * conformant and therefore compile spurious extra code for the large
++ * values.
++ *
++ * We can be reasonably sure that an unsigned to float conversion
++ * won't be faster than an int to float one. Therefore this code
++ * assumes responsibility for the undefined behavior, which it knows
++ * can't happen because of the check above.
++ *
++ * Note the argument to this routine is an (unsigned int) because, on
++ * 16-bit platforms, it is assigned a value which might be out of
++ * range for an (int); that would result in undefined behavior in the
++ * caller if the *argument* ('value') were to be declared (int).
++ */
++ double r = floor(255*pow((int)/*SAFE*/value/255.,gamma_val*.00001)+.5);
+ return (png_byte)r;
+ # else
+ png_int_32 lg2 = png_log8bit(value);
+ png_fixed_point res;
+
+- if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
++ if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
+ return png_exp8bit(res);
+
+ /* Overflow. */
+@@ -2116,19 +3823,26 @@
+ return (png_byte)value;
+ }
+
++#ifdef PNG_16BIT_SUPPORTED
+ png_uint_16
+ png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
+ {
+ if (value > 0 && value < 65535)
+ {
+ # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+- double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5);
++ /* The same (unsigned int)->(double) constraints apply here as above,
++ * however in this case the (unsigned int) to (int) conversion can
++ * overflow on an ANSI-C90 compliant system so the cast needs to ensure
++ * that this is not possible.
++ */
++ double r = floor(65535*pow((png_int_32)value/65535.,
++ gamma_val*.00001)+.5);
+ return (png_uint_16)r;
+ # else
+ png_int_32 lg2 = png_log16bit(value);
+ png_fixed_point res;
+
+- if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
++ if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
+ return png_exp16bit(res);
+
+ /* Overflow. */
+@@ -2138,6 +3852,7 @@
+
+ return (png_uint_16)value;
+ }
++#endif /* 16BIT */
+
+ /* This does the right thing based on the bit_depth field of the
+ * png_struct, interpreting values as 8-bit or 16-bit. While the result
+@@ -2145,26 +3860,22 @@
+ * 8-bit (as are the arguments.)
+ */
+ png_uint_16 /* PRIVATE */
+-png_gamma_correct(png_structp png_ptr, unsigned int value,
++png_gamma_correct(png_structrp png_ptr, unsigned int value,
+ png_fixed_point gamma_val)
+ {
+ if (png_ptr->bit_depth == 8)
+ return png_gamma_8bit_correct(value, gamma_val);
+
++#ifdef PNG_16BIT_SUPPORTED
+ else
+ return png_gamma_16bit_correct(value, gamma_val);
++#else
++ /* should not reach this */
++ return 0;
++#endif /* 16BIT */
+ }
+
+-/* This is the shared test on whether a gamma value is 'significant' - whether
+- * it is worth doing gamma correction.
+- */
+-int /* PRIVATE */
+-png_gamma_significant(png_fixed_point gamma_val)
+-{
+- return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
+- gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
+-}
+-
++#ifdef PNG_16BIT_SUPPORTED
+ /* Internal function to build a single 16-bit table - the table consists of
+ * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount
+ * to shift the input values right (or 16-number_of_signifiant_bits).
+@@ -2174,27 +3885,33 @@
+ * should be somewhere that will be cleaned.
+ */
+ static void
+-png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
++png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
+ PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
+ {
+ /* Various values derived from 'shift': */
+ PNG_CONST unsigned int num = 1U << (8U - shift);
++#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
++ /* CSE the division and work round wacky GCC warnings (see the comments
++ * in png_gamma_8bit_correct for where these come from.)
++ */
++ PNG_CONST double fmax = 1./(((png_int_32)1 << (16U - shift))-1);
++#endif
+ PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
+ PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
+ unsigned int i;
+
+ png_uint_16pp table = *ptable =
+- (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
++ (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
+
+ for (i = 0; i < num; i++)
+ {
+ png_uint_16p sub_table = table[i] =
+- (png_uint_16p)png_malloc(png_ptr, 256 * png_sizeof(png_uint_16));
++ (png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16)));
+
+ /* The 'threshold' test is repeated here because it can arise for one of
+ * the 16-bit tables even if the others don't hit it.
+ */
+- if (png_gamma_significant(gamma_val))
++ if (png_gamma_significant(gamma_val) != 0)
+ {
+ /* The old code would overflow at the end and this would cause the
+ * 'pow' function to return a result >1, resulting in an
+@@ -2210,10 +3927,13 @@
+ png_uint_32 ig = (j << (8-shift)) + i;
+ # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+ /* Inline the 'max' scaling operation: */
+- double d = floor(65535*pow(ig/(double)max, gamma_val*.00001)+.5);
++ /* See png_gamma_8bit_correct for why the cast to (int) is
++ * required here.
++ */
++ double d = floor(65535.*pow(ig*fmax, gamma_val*.00001)+.5);
+ sub_table[j] = (png_uint_16)d;
+ # else
+- if (shift)
++ if (shift != 0)
+ ig = (ig * 65535U + max_by_2)/max;
+
+ sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);
+@@ -2229,7 +3949,7 @@
+ {
+ png_uint_32 ig = (j << (8-shift)) + i;
+
+- if (shift)
++ if (shift != 0)
+ ig = (ig * 65535U + max_by_2)/max;
+
+ sub_table[j] = (png_uint_16)ig;
+@@ -2242,7 +3962,7 @@
+ * required.
+ */
+ static void
+-png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable,
++png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
+ PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
+ {
+ PNG_CONST unsigned int num = 1U << (8U - shift);
+@@ -2251,15 +3971,15 @@
+ png_uint_32 last;
+
+ png_uint_16pp table = *ptable =
+- (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
++ (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
+
+ /* 'num' is the number of tables and also the number of low bits of low
+ * bits of the input 16-bit value used to select a table. Each table is
+- * itself index by the high 8 bits of the value.
++ * itself indexed by the high 8 bits of the value.
+ */
+ for (i = 0; i < num; i++)
+ table[i] = (png_uint_16p)png_malloc(png_ptr,
+- 256 * png_sizeof(png_uint_16));
++ 256 * (sizeof (png_uint_16)));
+
+ /* 'gamma_val' is set to the reciprocal of the value calculated above, so
+ * pow(out,g) is an *input* value. 'last' is the last input value set.
+@@ -2303,23 +4023,84 @@
+ last++;
+ }
+ }
++#endif /* 16BIT */
+
+ /* Build a single 8-bit table: same as the 16-bit case but much simpler (and
+ * typically much faster). Note that libpng currently does no sBIT processing
+- * (apparently contrary to the spec) so a 256 entry table is always generated.
++ * (apparently contrary to the spec) so a 256-entry table is always generated.
+ */
+ static void
+-png_build_8bit_table(png_structp png_ptr, png_bytepp ptable,
++png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
+ PNG_CONST png_fixed_point gamma_val)
+ {
+ unsigned int i;
+ png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
+
+- if (png_gamma_significant(gamma_val)) for (i=0; i<256; i++)
+- table[i] = png_gamma_8bit_correct(i, gamma_val);
+-
+- else for (i=0; i<256; ++i)
+- table[i] = (png_byte)i;
++ if (png_gamma_significant(gamma_val) != 0)
++ for (i=0; i<256; i++)
++ table[i] = png_gamma_8bit_correct(i, gamma_val);
++
++ else
++ for (i=0; i<256; ++i)
++ table[i] = (png_byte)i;
++}
++
++/* Used from png_read_destroy and below to release the memory used by the gamma
++ * tables.
++ */
++void /* PRIVATE */
++png_destroy_gamma_table(png_structrp png_ptr)
++{
++ png_free(png_ptr, png_ptr->gamma_table);
++ png_ptr->gamma_table = NULL;
++
++#ifdef PNG_16BIT_SUPPORTED
++ if (png_ptr->gamma_16_table != NULL)
++ {
++ int i;
++ int istop = (1 << (8 - png_ptr->gamma_shift));
++ for (i = 0; i < istop; i++)
++ {
++ png_free(png_ptr, png_ptr->gamma_16_table[i]);
++ }
++ png_free(png_ptr, png_ptr->gamma_16_table);
++ png_ptr->gamma_16_table = NULL;
++ }
++#endif /* 16BIT */
++
++#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
++ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
++ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
++ png_free(png_ptr, png_ptr->gamma_from_1);
++ png_ptr->gamma_from_1 = NULL;
++ png_free(png_ptr, png_ptr->gamma_to_1);
++ png_ptr->gamma_to_1 = NULL;
++
++#ifdef PNG_16BIT_SUPPORTED
++ if (png_ptr->gamma_16_from_1 != NULL)
++ {
++ int i;
++ int istop = (1 << (8 - png_ptr->gamma_shift));
++ for (i = 0; i < istop; i++)
++ {
++ png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
++ }
++ png_free(png_ptr, png_ptr->gamma_16_from_1);
++ png_ptr->gamma_16_from_1 = NULL;
++ }
++ if (png_ptr->gamma_16_to_1 != NULL)
++ {
++ int i;
++ int istop = (1 << (8 - png_ptr->gamma_shift));
++ for (i = 0; i < istop; i++)
++ {
++ png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
++ }
++ png_free(png_ptr, png_ptr->gamma_16_to_1);
++ png_ptr->gamma_16_to_1 = NULL;
++ }
++#endif /* 16BIT */
++#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
+ }
+
+ /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
+@@ -2328,35 +4109,48 @@
+ * we don't need to allocate > 64K chunks for a full 16-bit table.
+ */
+ void /* PRIVATE */
+-png_build_gamma_table(png_structp png_ptr, int bit_depth)
++png_build_gamma_table(png_structrp png_ptr, int bit_depth)
+ {
+ png_debug(1, "in png_build_gamma_table");
+
++ /* Remove any existing table; this copes with multiple calls to
++ * png_read_update_info. The warning is because building the gamma tables
++ * multiple times is a performance hit - it's harmless but the ability to call
++ * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible
++ * to warn if the app introduces such a hit.
++ */
++ if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
++ {
++ png_warning(png_ptr, "gamma table being rebuilt");
++ png_destroy_gamma_table(png_ptr);
++ }
++
+ if (bit_depth <= 8)
+ {
+ png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
+- png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma,
++ png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
+ png_ptr->screen_gamma) : PNG_FP_1);
+
+ #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
+ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+- if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
++ if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
+ {
+ png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
+- png_reciprocal(png_ptr->gamma));
++ png_reciprocal(png_ptr->colorspace.gamma));
+
+ png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
+ png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
+- png_ptr->gamma/* Probably doing rgb_to_gray */);
++ png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
+ }
+ #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
+ }
++#ifdef PNG_16BIT_SUPPORTED
+ else
+ {
+ png_byte shift, sig_bit;
+
+- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+ sig_bit = png_ptr->sig_bit.red;
+
+@@ -2376,7 +4170,7 @@
+ * Where 'iv' is the input color value and 'ov' is the output value -
+ * pow(iv, gamma).
+ *
+- * Thus the gamma table consists of up to 256 256 entry tables. The table
++ * Thus the gamma table consists of up to 256 256-entry tables. The table
+ * is selected by the (8-gamma_shift) most significant of the low 8 bits of
+ * the color value then indexed by the upper 8 bits:
+ *
+@@ -2393,7 +4187,7 @@
+ else
+ shift = 0; /* keep all 16 bits */
+
+- if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))
++ if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
+ {
+ /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
+ * the significant bits in the *input* when the output will
+@@ -2408,32 +4202,28 @@
+
+ png_ptr->gamma_shift = shift;
+
+-#ifdef PNG_16BIT_SUPPORTED
+ /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
+ * PNG_COMPOSE). This effectively smashed the background calculation for
+ * 16-bit output because the 8-bit table assumes the result will be reduced
+ * to 8 bits.
+ */
+- if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))
+-#endif
++ if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
+ png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
+- png_ptr->screen_gamma > 0 ? png_product2(png_ptr->gamma,
++ png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,
+ png_ptr->screen_gamma) : PNG_FP_1);
+
+-#ifdef PNG_16BIT_SUPPORTED
+ else
+ png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
+- png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma,
++ png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
+ png_ptr->screen_gamma) : PNG_FP_1);
+-#endif
+
+ #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
+ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+- if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
++ if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
+ {
+ png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
+- png_reciprocal(png_ptr->gamma));
++ png_reciprocal(png_ptr->colorspace.gamma));
+
+ /* Notice that the '16 from 1' table should be full precision, however
+ * the lookup on this table still uses gamma_shift, so it can't be.
+@@ -2441,10 +4231,291 @@
+ */
+ png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
+ png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
+- png_ptr->gamma/* Probably doing rgb_to_gray */);
++ png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
+ }
+ #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
+ }
++#endif /* 16BIT */
+ }
+ #endif /* READ_GAMMA */
+-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
++
++/* HARDWARE OR SOFTWARE OPTION SUPPORT */
++#ifdef PNG_SET_OPTION_SUPPORTED
++int PNGAPI
++png_set_option(png_structrp png_ptr, int option, int onoff)
++{
++ if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&
++ (option & 1) == 0)
++ {
++ int mask = 3 << option;
++ int setting = (2 + (onoff != 0)) << option;
++ int current = png_ptr->options;
++
++ png_ptr->options = (png_byte)((current & ~mask) | setting);
++
++ return (current & mask) >> option;
++ }
++
++ return PNG_OPTION_INVALID;
++}
++#endif
++
++/* sRGB support */
++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
++ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
++/* sRGB conversion tables; these are machine generated with the code in
++ * contrib/tools/makesRGB.c. The actual sRGB transfer curve defined in the
++ * specification (see the article at http://en.wikipedia.org/wiki/SRGB)
++ * is used, not the gamma=1/2.2 approximation use elsewhere in libpng.
++ * The sRGB to linear table is exact (to the nearest 16 bit linear fraction).
++ * The inverse (linear to sRGB) table has accuracies as follows:
++ *
++ * For all possible (255*65535+1) input values:
++ *
++ * error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact
++ *
++ * For the input values corresponding to the 65536 16-bit values:
++ *
++ * error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact
++ *
++ * In all cases the inexact readings are only off by one.
++ */
++
++#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
++/* The convert-to-sRGB table is only currently required for read. */
++const png_uint_16 png_sRGB_table[256] =
++{
++ 0,20,40,60,80,99,119,139,
++ 159,179,199,219,241,264,288,313,
++ 340,367,396,427,458,491,526,562,
++ 599,637,677,718,761,805,851,898,
++ 947,997,1048,1101,1156,1212,1270,1330,
++ 1391,1453,1517,1583,1651,1720,1790,1863,
++ 1937,2013,2090,2170,2250,2333,2418,2504,
++ 2592,2681,2773,2866,2961,3058,3157,3258,
++ 3360,3464,3570,3678,3788,3900,4014,4129,
++ 4247,4366,4488,4611,4736,4864,4993,5124,
++ 5257,5392,5530,5669,5810,5953,6099,6246,
++ 6395,6547,6700,6856,7014,7174,7335,7500,
++ 7666,7834,8004,8177,8352,8528,8708,8889,
++ 9072,9258,9445,9635,9828,10022,10219,10417,
++ 10619,10822,11028,11235,11446,11658,11873,12090,
++ 12309,12530,12754,12980,13209,13440,13673,13909,
++ 14146,14387,14629,14874,15122,15371,15623,15878,
++ 16135,16394,16656,16920,17187,17456,17727,18001,
++ 18277,18556,18837,19121,19407,19696,19987,20281,
++ 20577,20876,21177,21481,21787,22096,22407,22721,
++ 23038,23357,23678,24002,24329,24658,24990,25325,
++ 25662,26001,26344,26688,27036,27386,27739,28094,
++ 28452,28813,29176,29542,29911,30282,30656,31033,
++ 31412,31794,32179,32567,32957,33350,33745,34143,
++ 34544,34948,35355,35764,36176,36591,37008,37429,
++ 37852,38278,38706,39138,39572,40009,40449,40891,
++ 41337,41785,42236,42690,43147,43606,44069,44534,
++ 45002,45473,45947,46423,46903,47385,47871,48359,
++ 48850,49344,49841,50341,50844,51349,51858,52369,
++ 52884,53401,53921,54445,54971,55500,56032,56567,
++ 57105,57646,58190,58737,59287,59840,60396,60955,
++ 61517,62082,62650,63221,63795,64372,64952,65535
++};
++#endif /* SIMPLIFIED_READ */
++
++/* The base/delta tables are required for both read and write (but currently
++ * only the simplified versions.)
++ */
++const png_uint_16 png_sRGB_base[512] =
++{
++ 128,1782,3383,4644,5675,6564,7357,8074,
++ 8732,9346,9921,10463,10977,11466,11935,12384,
++ 12816,13233,13634,14024,14402,14769,15125,15473,
++ 15812,16142,16466,16781,17090,17393,17690,17981,
++ 18266,18546,18822,19093,19359,19621,19879,20133,
++ 20383,20630,20873,21113,21349,21583,21813,22041,
++ 22265,22487,22707,22923,23138,23350,23559,23767,
++ 23972,24175,24376,24575,24772,24967,25160,25352,
++ 25542,25730,25916,26101,26284,26465,26645,26823,
++ 27000,27176,27350,27523,27695,27865,28034,28201,
++ 28368,28533,28697,28860,29021,29182,29341,29500,
++ 29657,29813,29969,30123,30276,30429,30580,30730,
++ 30880,31028,31176,31323,31469,31614,31758,31902,
++ 32045,32186,32327,32468,32607,32746,32884,33021,
++ 33158,33294,33429,33564,33697,33831,33963,34095,
++ 34226,34357,34486,34616,34744,34873,35000,35127,
++ 35253,35379,35504,35629,35753,35876,35999,36122,
++ 36244,36365,36486,36606,36726,36845,36964,37083,
++ 37201,37318,37435,37551,37668,37783,37898,38013,
++ 38127,38241,38354,38467,38580,38692,38803,38915,
++ 39026,39136,39246,39356,39465,39574,39682,39790,
++ 39898,40005,40112,40219,40325,40431,40537,40642,
++ 40747,40851,40955,41059,41163,41266,41369,41471,
++ 41573,41675,41777,41878,41979,42079,42179,42279,
++ 42379,42478,42577,42676,42775,42873,42971,43068,
++ 43165,43262,43359,43456,43552,43648,43743,43839,
++ 43934,44028,44123,44217,44311,44405,44499,44592,
++ 44685,44778,44870,44962,45054,45146,45238,45329,
++ 45420,45511,45601,45692,45782,45872,45961,46051,
++ 46140,46229,46318,46406,46494,46583,46670,46758,
++ 46846,46933,47020,47107,47193,47280,47366,47452,
++ 47538,47623,47709,47794,47879,47964,48048,48133,
++ 48217,48301,48385,48468,48552,48635,48718,48801,
++ 48884,48966,49048,49131,49213,49294,49376,49458,
++ 49539,49620,49701,49782,49862,49943,50023,50103,
++ 50183,50263,50342,50422,50501,50580,50659,50738,
++ 50816,50895,50973,51051,51129,51207,51285,51362,
++ 51439,51517,51594,51671,51747,51824,51900,51977,
++ 52053,52129,52205,52280,52356,52432,52507,52582,
++ 52657,52732,52807,52881,52956,53030,53104,53178,
++ 53252,53326,53400,53473,53546,53620,53693,53766,
++ 53839,53911,53984,54056,54129,54201,54273,54345,
++ 54417,54489,54560,54632,54703,54774,54845,54916,
++ 54987,55058,55129,55199,55269,55340,55410,55480,
++ 55550,55620,55689,55759,55828,55898,55967,56036,
++ 56105,56174,56243,56311,56380,56448,56517,56585,
++ 56653,56721,56789,56857,56924,56992,57059,57127,
++ 57194,57261,57328,57395,57462,57529,57595,57662,
++ 57728,57795,57861,57927,57993,58059,58125,58191,
++ 58256,58322,58387,58453,58518,58583,58648,58713,
++ 58778,58843,58908,58972,59037,59101,59165,59230,
++ 59294,59358,59422,59486,59549,59613,59677,59740,
++ 59804,59867,59930,59993,60056,60119,60182,60245,
++ 60308,60370,60433,60495,60558,60620,60682,60744,
++ 60806,60868,60930,60992,61054,61115,61177,61238,
++ 61300,61361,61422,61483,61544,61605,61666,61727,
++ 61788,61848,61909,61969,62030,62090,62150,62211,
++ 62271,62331,62391,62450,62510,62570,62630,62689,
++ 62749,62808,62867,62927,62986,63045,63104,63163,
++ 63222,63281,63340,63398,63457,63515,63574,63632,
++ 63691,63749,63807,63865,63923,63981,64039,64097,
++ 64155,64212,64270,64328,64385,64443,64500,64557,
++ 64614,64672,64729,64786,64843,64900,64956,65013,
++ 65070,65126,65183,65239,65296,65352,65409,65465
++};
++
++const png_byte png_sRGB_delta[512] =
++{
++ 207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54,
++ 52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36,
++ 35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28,
++ 28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24,
++ 23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21,
++ 21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19,
++ 19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17,
++ 17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16,
++ 16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15,
++ 15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14,
++ 14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13,
++ 13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,
++ 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
++ 12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11,
++ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
++ 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
++ 11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
++ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
++ 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
++ 10,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
++ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
++ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
++ 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
++ 9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++ 8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,
++ 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
++ 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
++ 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
++};
++#endif /* SIMPLIFIED READ/WRITE sRGB support */
++
++/* SIMPLIFIED READ/WRITE SUPPORT */
++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
++ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
++static int
++png_image_free_function(png_voidp argument)
++{
++ png_imagep image = png_voidcast(png_imagep, argument);
++ png_controlp cp = image->opaque;
++ png_control c;
++
++ /* Double check that we have a png_ptr - it should be impossible to get here
++ * without one.
++ */
++ if (cp->png_ptr == NULL)
++ return 0;
++
++ /* First free any data held in the control structure. */
++# ifdef PNG_STDIO_SUPPORTED
++ if (cp->owned_file != 0)
++ {
++ FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);
++ cp->owned_file = 0;
++
++ /* Ignore errors here. */
++ if (fp != NULL)
++ {
++ cp->png_ptr->io_ptr = NULL;
++ (void)fclose(fp);
++ }
++ }
++# endif
++
++ /* Copy the control structure so that the original, allocated, version can be
++ * safely freed. Notice that a png_error here stops the remainder of the
++ * cleanup, but this is probably fine because that would indicate bad memory
++ * problems anyway.
++ */
++ c = *cp;
++ image->opaque = &c;
++ png_free(c.png_ptr, cp);
++
++ /* Then the structures, calling the correct API. */
++ if (c.for_write != 0)
++ {
++# ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
++ png_destroy_write_struct(&c.png_ptr, &c.info_ptr);
++# else
++ png_error(c.png_ptr, "simplified write not supported");
++# endif
++ }
++ else
++ {
++# ifdef PNG_SIMPLIFIED_READ_SUPPORTED
++ png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL);
++# else
++ png_error(c.png_ptr, "simplified read not supported");
++# endif
++ }
++
++ /* Success. */
++ return 1;
++}
++
++void PNGAPI
++png_image_free(png_imagep image)
++{
++ /* Safely call the real function, but only if doing so is safe at this point
++ * (if not inside an error handling context). Otherwise assume
++ * png_safe_execute will call this API after the return.
++ */
++ if (image != NULL && image->opaque != NULL &&
++ image->opaque->error_buf == NULL)
++ {
++ /* Ignore errors here: */
++ (void)png_safe_execute(image, png_image_free_function, image);
++ image->opaque = NULL;
++ }
++}
++
++int /* PRIVATE */
++png_image_error(png_imagep image, png_const_charp error_message)
++{
++ /* Utility to log an error. */
++ png_safecat(image->message, (sizeof image->message), 0, error_message);
++ image->warning_or_error |= PNG_IMAGE_ERROR;
++ png_image_free(image);
++ return 0;
++}
++
++#endif /* SIMPLIFIED READ/WRITE */
++#endif /* READ || WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/png.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/png.h Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * libpng version 1.5.4 - July 7, 2011
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * libpng version 1.6.16, December 22, 2014
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -39,7 +39,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.5.4 - July 7, 2011: Glenn
++ * libpng versions 0.97, January 1998, through 1.6.16, December 22, 2014: Glenn
+ * See also "Contributing Authors", below.
+ *
+ * Note about libpng version numbers:
+@@ -185,6 +185,61 @@
+ * 1.5.4beta01-08 15 10504 15.so.15.4[.0]
+ * 1.5.4rc01 15 10504 15.so.15.4[.0]
+ * 1.5.4 15 10504 15.so.15.4[.0]
++ * 1.5.5beta01-08 15 10505 15.so.15.5[.0]
++ * 1.5.5rc01 15 10505 15.so.15.5[.0]
++ * 1.5.5 15 10505 15.so.15.5[.0]
++ * 1.5.6beta01-07 15 10506 15.so.15.6[.0]
++ * 1.5.6rc01-03 15 10506 15.so.15.6[.0]
++ * 1.5.6 15 10506 15.so.15.6[.0]
++ * 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-40 16 10600 16.so.16.0[.0]
++ * 1.6.0rc01-08 16 10600 16.so.16.0[.0]
++ * 1.6.0 16 10600 16.so.16.0[.0]
++ * 1.6.1beta01-09 16 10601 16.so.16.1[.0]
++ * 1.6.1rc01 16 10601 16.so.16.1[.0]
++ * 1.6.1 16 10601 16.so.16.1[.0]
++ * 1.6.2beta01 16 10602 16.so.16.2[.0]
++ * 1.6.2rc01-06 16 10602 16.so.16.2[.0]
++ * 1.6.2 16 10602 16.so.16.2[.0]
++ * 1.6.3beta01-11 16 10603 16.so.16.3[.0]
++ * 1.6.3rc01 16 10603 16.so.16.3[.0]
++ * 1.6.3 16 10603 16.so.16.3[.0]
++ * 1.6.4beta01-02 16 10604 16.so.16.4[.0]
++ * 1.6.4rc01 16 10604 16.so.16.4[.0]
++ * 1.6.4 16 10604 16.so.16.4[.0]
++ * 1.6.5 16 10605 16.so.16.5[.0]
++ * 1.6.6 16 10606 16.so.16.6[.0]
++ * 1.6.7beta01-04 16 10607 16.so.16.7[.0]
++ * 1.6.7rc01-03 16 10607 16.so.16.7[.0]
++ * 1.6.7 16 10607 16.so.16.7[.0]
++ * 1.6.8beta01-02 16 10608 16.so.16.8[.0]
++ * 1.6.8rc01-02 16 10608 16.so.16.8[.0]
++ * 1.6.8 16 10608 16.so.16.8[.0]
++ * 1.6.9beta01-04 16 10609 16.so.16.9[.0]
++ * 1.6.9rc01-02 16 10609 16.so.16.9[.0]
++ * 1.6.9 16 10609 16.so.16.9[.0]
++ * 1.6.10beta01-03 16 10610 16.so.16.10[.0]
++ * 1.6.10rc01-03 16 10610 16.so.16.10[.0]
++ * 1.6.10 16 10610 16.so.16.10[.0]
++ * 1.6.11beta01-06 16 10611 16.so.16.11[.0]
++ * 1.6.11rc01-02 16 10611 16.so.16.11[.0]
++ * 1.6.11 16 10611 16.so.16.11[.0]
++ * 1.6.12rc01-03 16 10612 16.so.16.12[.0]
++ * 1.6.12 16 10612 16.so.16.12[.0]
++ * 1.6.13beta01-04 16 10613 16.so.16.13[.0]
++ * 1.6.13rc01-02 16 10613 16.so.16.13[.0]
++ * 1.6.13 16 10613 16.so.16.13[.0]
++ * 1.6.14beta01-07 16 10614 16.so.16.14[.0]
++ * 1.6.14rc01-02 16 10614 16.so.16.14[.0]
++ * 1.6.14 16 10614 16.so.16.14[.0]
++ * 1.6.15beta01-08 16 10615 16.so.16.15[.0]
++ * 1.6.15rc01-03 16 10615 16.so.16.15[.0]
++ * 1.6.15 16 10615 16.so.16.15[.0]
++ * 1.6.16beta01-03 16 10616 16.so.16.16[.0]
++ * 1.6.16rc01-02 16 10616 16.so.16.16[.0]
++ * 1.6.16 16 10616 16.so.16.16[.0]
+ *
+ * Henceforth the source version will match the shared-library major
+ * and minor numbers; the shared-library major version number will be
+@@ -194,7 +249,7 @@
+ * to the source version x.y.z (leading zeros in y and z). Beta versions
+ * were given the previous public release number plus a letter, until
+ * version 1.0.6j; from then on they were given the upcoming public
+- * release number plus "betaNN" or "rcN".
++ * release number plus "betaNN" or "rcNN".
+ *
+ * Binary incompatibility exists only when applications make direct access
+ * to the info_ptr or png_ptr members through png.h, and the compiled
+@@ -216,8 +271,8 @@
+ *
+ * This code is released under the libpng license.
+ *
+- * libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+- * Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++ * libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++ * Copyright (c) 2004, 2006-2014 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:
+ *
+@@ -328,28 +383,30 @@
+ * Y2K compliance in libpng:
+ * =========================
+ *
+- * July 7, 2011
++ * December 22, 2014
+ *
+ * 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.5.4 are Y2K compliant. It is my belief that
++ * upward through 1.6.16 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
+- * that will hold years up to 65535. The other holds the date in text
+- * format, and will hold years up to 9999.
++ * that will hold years up to 65535. The other, which is deprecated,
++ * holds the date in text format, and will hold years up to 9999.
+ *
+ * The integer is
+ * "png_uint_16 year" in png_time_struct.
+ *
+ * The string is
+- * "png_char time_buffer" in png_struct
++ * "char time_buffer[29]" in png_struct. This is no longer used
++ * in libpng-1.6.x and will be removed from libpng-1.7.0.
+ *
+ * There are seven time-related functions:
+- * png.c: png_convert_to_rfc_1123() in png.c
+- * (formerly png_convert_to_rfc_1152() in error)
++ * png.c: png_convert_to_rfc_1123_buffer() in png.c
++ * (formerly png_convert_to_rfc_1123() prior to libpng-1.5.x and
++ * png_convert_to_rfc_1152() in error prior to libpng-0.98)
+ * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
+ * png_convert_from_time_t() in pngwrite.c
+ * png_get_tIME() in pngget.c
+@@ -360,8 +417,8 @@
+ * All handle dates properly in a Y2K environment. The
+ * png_convert_from_time_t() function calls gmtime() to convert from system
+ * clock time, which returns (year - 1900), which we properly convert to
+- * the full 4-digit year. There is a possibility that applications using
+- * libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
++ * the full 4-digit year. There is a possibility that libpng applications
++ * are not passing 4-digit years into the png_convert_to_rfc_1123_buffer()
+ * function, or that they are incorrectly passing only a 2-digit year
+ * instead of "year - 1900" into the png_convert_from_struct_tm() function,
+ * but this is not under our control. The libpng documentation has always
+@@ -385,21 +442,27 @@
+ /* This is not the place to learn how to use libpng. The file libpng-manual.txt
+ * describes how to use libpng, and the file example.c summarizes it
+ * with some code on which to build. This file is useful for looking
+- * at the actual function definitions and structure components.
++ * at the actual function definitions and structure components. If that
++ * file has been stripped from your copy of libpng, you can find it at
++ * <http://www.libpng.org/pub/png/libpng-manual.txt>
++ *
++ * If you just need to read a PNG file and don't want to read the documentation
++ * skip to the end of this file and read the section entitled 'simplified API'.
+ */
+
+ /* Version information for png.h - this should match the version in png.c */
+-#define PNG_LIBPNG_VER_STRING "1.5.4"
++#define PNG_LIBPNG_VER_STRING "1.6.16"
+ #define PNG_HEADER_VERSION_STRING \
+- " libpng version 1.5.4 - July 7, 2011\n"
+-
+-#define PNG_LIBPNG_VER_SONUM 15
+-#define PNG_LIBPNG_VER_DLLNUM 15
++ " libpng version 1.6.16 - December 22, 2014\n"
++
++#define PNG_LIBPNG_VER_SONUM 16
++#define PNG_LIBPNG_VER_DLLNUM 16
+
+ /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
+ #define PNG_LIBPNG_VER_MAJOR 1
+-#define PNG_LIBPNG_VER_MINOR 5
+-#define PNG_LIBPNG_VER_RELEASE 4
++#define PNG_LIBPNG_VER_MINOR 6
++#define PNG_LIBPNG_VER_RELEASE 16
++
+ /* This should match the numeric part of the final component of
+ * PNG_LIBPNG_VER_STRING, omitting any leading zero:
+ */
+@@ -421,7 +484,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_STABLE
+
+ /* Careful here. At one time, Guy wanted to use 082, but that would be octal.
+ * We must not include leading zeros.
+@@ -429,7 +492,7 @@
+ * version 1.0.0 was mis-numbered 100 instead of 10000). From
+ * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release
+ */
+-#define PNG_LIBPNG_VER 10504 /* 1.5.4 */
++#define PNG_LIBPNG_VER 10616 /* 1.6.16 */
+
+ /* Library configuration: these options cannot be changed after
+ * the library has been built.
+@@ -442,25 +505,7 @@
+ #endif
+
+ #ifndef PNG_VERSION_INFO_ONLY
+-# ifndef PNG_BUILDING_SYMBOL_TABLE
+- /*
+- * Standard header files (not needed for the version info or while
+- * building symbol table -- see scripts/pnglibconf.dfa)
+- */
+-# ifdef PNG_SETJMP_SUPPORTED
+-# include <setjmp.h>
+-# endif
+-
+- /* Need the time information for converting tIME chunks, it
+- * defines struct tm:
+- */
+-# ifdef PNG_CONVERT_tIME_SUPPORTED
+- /* "time.h" functions are not supported on all operating systems */
+-# include <time.h>
+-# endif
+-# endif
+-
+-/* Machine specific configuration. */
++ /* Machine specific configuration. */
+ # include "pngconf.h"
+ #endif
+
+@@ -509,6 +554,7 @@
+ * 2. Type definitions (base types are defined in pngconf.h), structure
+ * definitions.
+ * 3. Exported library functions.
++ * 4. Simplified API.
+ *
+ * The library source code has additional files (principally pngpriv.h) that
+ * allow configuration of the library.
+@@ -551,7 +597,48 @@
+ /* 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_5_4;
++typedef char* png_libpng_version_1_6_16;
++
++/* Basic control structions. Read libpng-manual.txt or libpng.3 for more info.
++ *
++ * png_struct is the cache of information used while reading or writing a single
++ * PNG file. One of these is always required, although the simplified API
++ * (below) hides the creation and destruction of it.
++ */
++typedef struct png_struct_def png_struct;
++typedef const png_struct * png_const_structp;
++typedef png_struct * png_structp;
++typedef png_struct * * png_structpp;
++
++/* png_info contains information read from or to be written to a PNG file. One
++ * or more of these must exist while reading or creating a PNG file. The
++ * information is not used by libpng during read but is used to control what
++ * gets written when a PNG file is created. "png_get_" function calls read
++ * information during read and "png_set_" functions calls write information
++ * when creating a PNG.
++ * been moved into a separate header file that is not accessible to
++ * applications. Read libpng-manual.txt or libpng.3 for more info.
++ */
++typedef struct png_info_def png_info;
++typedef png_info * png_infop;
++typedef const png_info * png_const_infop;
++typedef png_info * * png_infopp;
++
++/* Types with names ending 'p' are pointer types. The corresponding types with
++ * names ending 'rp' are identical pointer types except that the pointer is
++ * marked 'restrict', which means that it is the only pointer to the object
++ * passed to the function. Applications should not use the 'restrict' types;
++ * it is always valid to pass 'p' to a pointer with a function argument of the
++ * corresponding 'rp' type. Different compilers have different rules with
++ * regard to type matching in the presence of 'restrict'. For backward
++ * compatibility libpng callbacks never have 'restrict' in their parameters and,
++ * consequentially, writing portable application code is extremely difficult if
++ * an attempt is made to use 'restrict'.
++ */
++typedef png_struct * PNG_RESTRICT png_structrp;
++typedef const png_struct * PNG_RESTRICT png_const_structrp;
++typedef png_info * PNG_RESTRICT png_inforp;
++typedef const png_info * PNG_RESTRICT png_const_inforp;
+
+ /* Three color definitions. The order of the red, green, and blue, (and the
+ * exact size) is not important, although the size of the fields need to
+@@ -563,9 +650,9 @@
+ png_byte green;
+ png_byte blue;
+ } png_color;
+-typedef png_color FAR * png_colorp;
+-typedef PNG_CONST png_color FAR * png_const_colorp;
+-typedef png_color FAR * FAR * png_colorpp;
++typedef png_color * png_colorp;
++typedef const png_color * png_const_colorp;
++typedef png_color * * png_colorpp;
+
+ typedef struct png_color_16_struct
+ {
+@@ -575,9 +662,9 @@
+ png_uint_16 blue;
+ png_uint_16 gray; /* for use in grayscale files */
+ } png_color_16;
+-typedef png_color_16 FAR * png_color_16p;
+-typedef PNG_CONST png_color_16 FAR * png_const_color_16p;
+-typedef png_color_16 FAR * FAR * png_color_16pp;
++typedef png_color_16 * png_color_16p;
++typedef const png_color_16 * png_const_color_16p;
++typedef png_color_16 * * png_color_16pp;
+
+ typedef struct png_color_8_struct
+ {
+@@ -587,9 +674,9 @@
+ png_byte gray; /* for use in grayscale files */
+ png_byte alpha; /* for alpha channel files */
+ } png_color_8;
+-typedef png_color_8 FAR * png_color_8p;
+-typedef PNG_CONST png_color_8 FAR * png_const_color_8p;
+-typedef png_color_8 FAR * FAR * png_color_8pp;
++typedef png_color_8 * png_color_8p;
++typedef const png_color_8 * png_const_color_8p;
++typedef png_color_8 * * png_color_8pp;
+
+ /*
+ * The following two structures are used for the in-core representation
+@@ -603,9 +690,9 @@
+ png_uint_16 alpha;
+ png_uint_16 frequency;
+ } png_sPLT_entry;
+-typedef png_sPLT_entry FAR * png_sPLT_entryp;
+-typedef PNG_CONST png_sPLT_entry FAR * png_const_sPLT_entryp;
+-typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;
++typedef png_sPLT_entry * png_sPLT_entryp;
++typedef const png_sPLT_entry * png_const_sPLT_entryp;
++typedef png_sPLT_entry * * png_sPLT_entrypp;
+
+ /* When the depth of the sPLT palette is 8 bits, the color and alpha samples
+ * occupy the LSB of their respective members, and the MSB of each member
+@@ -619,18 +706,27 @@
+ png_sPLT_entryp entries; /* palette entries */
+ png_int_32 nentries; /* number of palette entries */
+ } png_sPLT_t;
+-typedef png_sPLT_t FAR * png_sPLT_tp;
+-typedef PNG_CONST png_sPLT_t FAR * png_const_sPLT_tp;
+-typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;
++typedef png_sPLT_t * png_sPLT_tp;
++typedef const png_sPLT_t * png_const_sPLT_tp;
++typedef png_sPLT_t * * png_sPLT_tpp;
+
+ #ifdef PNG_TEXT_SUPPORTED
+ /* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
+ * and whether that contents is compressed or not. The "key" field
+- * points to a regular zero-terminated C string. The "text", "lang", and
+- * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.
++ * points to a regular zero-terminated C string. The "text" fields can be a
++ * regular C string, an empty string, or a NULL pointer.
+ * However, the structure returned by png_get_text() will always contain
+- * regular zero-terminated C strings (possibly empty), never NULL pointers,
+- * so they can be safely used in printf() and other string-handling functions.
++ * the "text" field as a regular zero-terminated C string (possibly
++ * empty), never a NULL pointer, so it can be safely used in printf() and
++ * other string-handling functions. Note that the "itxt_length", "lang", and
++ * "lang_key" members of the structure only exist when the library is built
++ * with iTXt chunk support. Prior to libpng-1.4.0 the library was built by
++ * default without iTXt support. Also note that when iTXt *is* supported,
++ * the "lang" and "lang_key" fields contain NULL pointers when the
++ * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or
++ * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the
++ * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag"
++ * which is always 0 or 1, or its "compression method" which is always 0.
+ */
+ typedef struct png_text_struct
+ {
+@@ -649,9 +745,9 @@
+ png_charp lang_key; /* keyword translated UTF-8 string, 0 or more
+ chars or a NULL pointer */
+ } png_text;
+-typedef png_text FAR * png_textp;
+-typedef PNG_CONST png_text FAR * png_const_textp;
+-typedef png_text FAR * FAR * png_textpp;
++typedef png_text * png_textp;
++typedef const png_text * png_const_textp;
++typedef png_text * * png_textpp;
+ #endif
+
+ /* Supported compression types for text in PNG files (tEXt, and zTXt).
+@@ -679,49 +775,45 @@
+ png_byte minute; /* minute of hour, 0 - 59 */
+ png_byte second; /* second of minute, 0 - 60 (for leap seconds) */
+ } png_time;
+-typedef png_time FAR * png_timep;
+-typedef PNG_CONST png_time FAR * png_const_timep;
+-typedef png_time FAR * FAR * png_timepp;
+-
+-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \
+- defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
++typedef png_time * png_timep;
++typedef const png_time * png_const_timep;
++typedef png_time * * png_timepp;
++
++#if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) ||\
++ defined(PNG_USER_CHUNKS_SUPPORTED)
+ /* png_unknown_chunk is a structure to hold queued chunks for which there is
+ * no specific support. The idea is that we can use this to queue
+ * up private chunks for output even though the library doesn't actually
+ * know about their semantics.
++ *
++ * The data in the structure is set by libpng on read and used on write.
+ */
+ typedef struct png_unknown_chunk_t
+ {
+- png_byte name[5];
+- png_byte *data;
++ png_byte name[5]; /* Textual chunk name with '\0' terminator */
++ png_byte *data; /* Data, should not be modified on read! */
+ png_size_t size;
+
+- /* libpng-using applications should NOT directly modify this byte. */
++ /* On write 'location' must be set using the flag values listed below.
++ * Notice that on read it is set by libpng however the values stored have
++ * more bits set than are listed below. Always treat the value as a
++ * bitmask. On write set only one bit - setting multiple bits may cause the
++ * chunk to be written in multiple places.
++ */
+ png_byte location; /* mode of operation at read time */
+ }
+-
+-
+ png_unknown_chunk;
+-typedef png_unknown_chunk FAR * png_unknown_chunkp;
+-typedef PNG_CONST png_unknown_chunk FAR * png_const_unknown_chunkp;
+-typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;
++
++typedef png_unknown_chunk * png_unknown_chunkp;
++typedef const png_unknown_chunk * png_const_unknown_chunkp;
++typedef png_unknown_chunk * * png_unknown_chunkpp;
+ #endif
+
+-/* Values for the unknown chunk location byte */
+-
++/* Flag values for the unknown chunk location byte. */
+ #define PNG_HAVE_IHDR 0x01
+ #define PNG_HAVE_PLTE 0x02
+ #define PNG_AFTER_IDAT 0x08
+
+-/* The complete definition of png_info has, as of libpng-1.5.0,
+- * been moved into a separate header file that is not accessible to
+- * applications. Read libpng-manual.txt or libpng.3 for more info.
+- */
+-typedef struct png_info_def png_info;
+-typedef png_info FAR * png_infop;
+-typedef PNG_CONST png_info FAR * png_const_infop;
+-typedef png_info FAR * FAR * png_infopp;
+-
+ /* Maximum positive integer used in PNG is (2^31)-1 */
+ #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
+ #define PNG_UINT_32_MAX ((png_uint_32)(-1))
+@@ -821,7 +913,7 @@
+ #define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */
+ #define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */
+ #define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */
+-#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */
++#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */
+
+ /* This is used for the transformation routines, as some of them
+ * change these values for the row. It also should enable using
+@@ -837,16 +929,8 @@
+ png_byte pixel_depth; /* bits per pixel (depth * channels) */
+ } png_row_info;
+
+-typedef png_row_info FAR * png_row_infop;
+-typedef png_row_info FAR * FAR * png_row_infopp;
+-
+-/* The complete definition of png_struct has, as of libpng-1.5.0,
+- * been moved into a separate header file that is not accessible to
+- * applications. Read libpng-manual.txt or libpng.3 for more info.
+- */
+-typedef struct png_struct_def png_struct;
+-typedef PNG_CONST png_struct FAR * png_const_structp;
+-typedef png_struct FAR * png_structp;
++typedef png_row_info * png_row_infop;
++typedef png_row_info * * png_row_infopp;
+
+ /* These are the function types for the I/O functions and for the functions
+ * that allow the user to override the default I/O functions with his or her
+@@ -893,7 +977,8 @@
+ png_unknown_chunkp));
+ #endif
+ #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+-typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp));
++/* not used anywhere */
++/* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */
+ #endif
+
+ #ifdef PNG_SETJMP_SUPPORTED
+@@ -949,8 +1034,6 @@
+ png_alloc_size_t));
+ typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp));
+
+-typedef png_struct FAR * FAR * png_structpp;
+-
+ /* Section 3: exported functions
+ * Here are the function definitions most commonly used. This is not
+ * the place to find out how to use libpng. See libpng-manual.txt for the
+@@ -986,7 +1069,7 @@
+ /* Tell lib we have already handled the first <num_bytes> magic bytes.
+ * Handling more than 8 bytes from the beginning of the file is an error.
+ */
+-PNG_EXPORT(2, void, png_set_sig_bytes, (png_structp png_ptr, int num_bytes));
++PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
+
+ /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
+ * PNG file. Returns zero if the supplied bytes match the 8-byte PNG
+@@ -1014,9 +1097,9 @@
+ PNG_ALLOCATED);
+
+ PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size,
+- (png_const_structp png_ptr));
+-
+-PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structp png_ptr,
++ (png_const_structrp png_ptr));
++
++PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr,
+ png_size_t size));
+
+ /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
+@@ -1030,10 +1113,10 @@
+ * allocated by the library - the call will return NULL on a mismatch
+ * indicating an ABI mismatch.
+ */
+-PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr,
++PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr,
+ png_longjmp_ptr longjmp_fn, size_t jmp_buf_size));
+ # define png_jmpbuf(png_ptr) \
+- (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf)))
++ (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))
+ #else
+ # define png_jmpbuf(png_ptr) \
+ (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
+@@ -1043,12 +1126,12 @@
+ * will use it; otherwise it will call PNG_ABORT(). This function was
+ * added in libpng-1.5.0.
+ */
+-PNG_EXPORTA(9, void, png_longjmp, (png_structp png_ptr, int val),
++PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
+ PNG_NORETURN);
+
+ #ifdef PNG_READ_SUPPORTED
+ /* Reset the compression stream */
+-PNG_EXPORT(10, int, png_reset_zstream, (png_structp png_ptr));
++PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
+ #endif
+
+ /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
+@@ -1066,91 +1149,107 @@
+ #endif
+
+ /* Write the PNG file signature. */
+-PNG_EXPORT(13, void, png_write_sig, (png_structp png_ptr));
++PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
+
+ /* Write a PNG chunk - size, type, (optional) data, CRC. */
+-PNG_EXPORT(14, void, png_write_chunk, (png_structp png_ptr, png_const_bytep
++PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
+ chunk_name, png_const_bytep data, png_size_t length));
+
+ /* Write the start of a PNG chunk - length and chunk name. */
+-PNG_EXPORT(15, void, png_write_chunk_start, (png_structp png_ptr,
++PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
+ png_const_bytep chunk_name, png_uint_32 length));
+
+ /* Write the data of a PNG chunk started with png_write_chunk_start(). */
+-PNG_EXPORT(16, void, png_write_chunk_data, (png_structp png_ptr,
++PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
+ png_const_bytep data, png_size_t length));
+
+ /* Finish a chunk started with png_write_chunk_start() (includes CRC). */
+-PNG_EXPORT(17, void, png_write_chunk_end, (png_structp png_ptr));
++PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
+
+ /* Allocate and initialize the info structure */
+-PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_structp png_ptr),
++PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
+ PNG_ALLOCATED);
+
+-PNG_EXPORT(19, void, png_info_init_3, (png_infopp info_ptr,
+- png_size_t png_info_struct_size));
++/* DEPRECATED: this function allowed init structures to be created using the
++ * default allocation method (typically malloc). Use is deprecated in 1.6.0 and
++ * the API will be removed in the future.
++ */
++PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr,
++ png_size_t png_info_struct_size), PNG_DEPRECATED);
+
+ /* Writes all the PNG information before the image. */
+ PNG_EXPORT(20, void, png_write_info_before_PLTE,
+- (png_structp png_ptr, png_infop info_ptr));
++ (png_structrp png_ptr, png_const_inforp info_ptr));
+ PNG_EXPORT(21, void, png_write_info,
+- (png_structp png_ptr, png_infop info_ptr));
++ (png_structrp png_ptr, png_const_inforp info_ptr));
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read the information before the actual image data. */
+ PNG_EXPORT(22, void, png_read_info,
+- (png_structp png_ptr, png_infop info_ptr));
++ (png_structrp png_ptr, png_inforp info_ptr));
+ #endif
+
+ #ifdef PNG_TIME_RFC1123_SUPPORTED
+-PNG_EXPORT(23, png_const_charp, png_convert_to_rfc1123,
+- (png_structp png_ptr,
++ /* Convert to a US string format: there is no localization support in this
++ * routine. The original implementation used a 29 character buffer in
++ * png_struct, this will be removed in future versions.
++ */
++#if PNG_LIBPNG_VER < 10700
++/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */
++PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
++ png_const_timep ptime),PNG_DEPRECATED);
++#endif
++PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29],
+ png_const_timep ptime));
+ #endif
+
+ #ifdef PNG_CONVERT_tIME_SUPPORTED
+ /* Convert from a struct tm to png_time */
+ PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime,
+- PNG_CONST struct tm FAR * ttime));
++ const struct tm * ttime));
+
+ /* Convert from time_t to png_time. Uses gmtime() */
+-PNG_EXPORT(25, void, png_convert_from_time_t,
+- (png_timep ptime, time_t ttime));
+-#endif /* PNG_CONVERT_tIME_SUPPORTED */
++PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime));
++#endif /* CONVERT_tIME */
+
+ #ifdef PNG_READ_EXPAND_SUPPORTED
+ /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
+-PNG_EXPORT(26, void, png_set_expand, (png_structp png_ptr));
+-PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structp png_ptr));
+-PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structp png_ptr));
+-PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structp png_ptr));
++PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr));
++PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr));
++PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr));
++PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_READ_EXPAND_16_SUPPORTED
+ /* Expand to 16-bit channels, forces conversion of palette to RGB and expansion
+ * of a tRNS chunk if present.
+ */
+-PNG_EXPORT(221, void, png_set_expand_16, (png_structp png_ptr));
++PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+ /* Use blue, green, red order for pixels. */
+-PNG_EXPORT(30, void, png_set_bgr, (png_structp png_ptr));
++PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+ /* Expand the grayscale to 24-bit RGB if necessary. */
+-PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structp png_ptr));
++PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+ /* Reduce RGB to grayscale. */
+-PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structp png_ptr,
+- int error_action, double red, double green));
+-PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structp png_ptr,
+- int error_action, png_fixed_point red, png_fixed_point green));
+-
+-PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structp
++#define PNG_ERROR_ACTION_NONE 1
++#define PNG_ERROR_ACTION_WARN 2
++#define PNG_ERROR_ACTION_ERROR 3
++#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/
++
++PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr,
++ int error_action, double red, double green))
++PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr,
++ int error_action, png_fixed_point red, png_fixed_point green))
++
++PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp
+ png_ptr));
+ #endif
+
+@@ -1160,9 +1259,9 @@
+ #endif
+
+ #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+-/* How the alpha channel is interpreted - this affects how the color channels of
+- * a PNG file are returned when an alpha channel, or tRNS chunk in a palette
+- * file, is present.
++/* How the alpha channel is interpreted - this affects how the color channels
++ * of a PNG file are returned to the calling application when an alpha channel,
++ * or a tRNS chunk in a palette file, is present.
+ *
+ * This has no effect on the way pixels are written into a PNG output
+ * datastream. The color samples in a PNG datastream are never premultiplied
+@@ -1170,33 +1269,19 @@
+ *
+ * The default is to return data according to the PNG specification: the alpha
+ * channel is a linear measure of the contribution of the pixel to the
+- * corresponding composited pixel. The gamma encoded color channels must be
+- * scaled according to the contribution and to do this it is necessary to undo
++ * corresponding composited pixel, and the color channels are unassociated
++ * (not premultiplied). The gamma encoded color channels must be scaled
++ * according to the contribution and to do this it is necessary to undo
+ * the encoding, scale the color values, perform the composition and reencode
+ * the values. This is the 'PNG' mode.
+ *
+ * The alternative is to 'associate' the alpha with the color information by
+- * storing color channel values that have been scaled by the alpha. The
+- * advantage is that the color channels can be resampled (the image can be
+- * scaled) in this form. The disadvantage is that normal practice is to store
+- * linear, not (gamma) encoded, values and this requires 16-bit channels for
+- * still images rather than the 8-bit channels that are just about sufficient if
+- * gamma encoding is used. In addition all non-transparent pixel values,
+- * including completely opaque ones, must be gamma encoded to produce the final
+- * image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the
+- * latter being the two common names for associated alpha color channels.)
++ * storing color channel values that have been scaled by the alpha.
++ * image. These are the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' modes
++ * (the latter being the two common names for associated alpha color channels).
+ *
+- * Since it is not necessary to perform arithmetic on opaque color values so
+- * long as they are not to be resampled and are in the final color space it is
+- * possible to optimize the handling of alpha by storing the opaque pixels in
+- * the PNG format (adjusted for the output color space) while storing partially
+- * opaque pixels in the standard, linear, format. The accuracy required for
+- * standard alpha composition is relatively low, because the pixels are
+- * isolated, therefore typically the accuracy loss in storing 8-bit linear
+- * values is acceptable. (This is not true if the alpha channel is used to
+- * simulate transparency over large areas - use 16 bits or the PNG mode in
+- * this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is
+- * treated as opaque only if the alpha value is equal to the maximum value.
++ * For the 'OPTIMIZED' mode, a pixel is treated as opaque only if the alpha
++ * value is equal to the maximum value.
+ *
+ * The final choice is to gamma encode the alpha channel as well. This is
+ * broken because, in practice, no implementation that uses this choice
+@@ -1215,76 +1300,15 @@
+ #define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */
+ #define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */
+
+-PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structp png_ptr, int mode,
+- double output_gamma));
+-PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structp png_ptr,
+- int mode, png_fixed_point output_gamma));
++PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode,
++ double output_gamma))
++PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr,
++ int mode, png_fixed_point output_gamma))
+ #endif
+
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED)
++#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+ /* The output_gamma value is a screen gamma in libpng terminology: it expresses
+- * how to decode the output values, not how they are encoded. The values used
+- * correspond to the normal numbers used to describe the overall gamma of a
+- * computer display system; for example 2.2 for an sRGB conformant system. The
+- * values are scaled by 100000 in the _fixed version of the API (so 220000 for
+- * sRGB.)
+- *
+- * The inverse of the value is always used to provide a default for the PNG file
+- * encoding if it has no gAMA chunk and if png_set_gamma() has not been called
+- * to override the PNG gamma information.
+- *
+- * When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode
+- * opaque pixels however pixels with lower alpha values are not encoded,
+- * regardless of the output gamma setting.
+- *
+- * When the standard Porter Duff handling is requested with mode 1 the output
+- * encoding is set to be linear and the output_gamma value is only relevant
+- * as a default for input data that has no gamma information. The linear output
+- * encoding will be overridden if png_set_gamma() is called - the results may be
+- * highly unexpected!
+- *
+- * The following numbers are derived from the sRGB standard and the research
+- * behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of
+- * 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing
+- * correction required to take account of any differences in the color
+- * environment of the original scene and the intended display environment; the
+- * value expresses how to *decode* the image for display, not how the original
+- * data was *encoded*.
+- *
+- * sRGB provides a peg for the PNG standard by defining a viewing environment.
+- * sRGB itself, and earlier TV standards, actually use a more complex transform
+- * (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is
+- * limited to simple power laws.) By saying that an image for direct display on
+- * an sRGB conformant system should be stored with a gAMA chunk value of 45455
+- * (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification
+- * makes it possible to derive values for other display systems and
+- * environments.
+- *
+- * The Mac value is deduced from the sRGB based on an assumption that the actual
+- * extra viewing correction used in early Mac display systems was implemented as
+- * a power 1.45 lookup table.
+- *
+- * Any system where a programmable lookup table is used or where the behavior of
+- * the final display device characteristics can be changed requires system
+- * specific code to obtain the current characteristic. However this can be
+- * difficult and most PNG gamma correction only requires an approximate value.
+- *
+- * By default, if png_set_alpha_mode() is not called, libpng assumes that all
+- * values are unencoded, linear, values and that the output device also has a
+- * linear characteristic. This is only very rarely correct - it is invariably
+- * better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the
+- * default if you don't know what the right answer is!
+- *
+- * The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS
+- * 10.6) which used a correction table to implement a somewhat lower gamma on an
+- * otherwise sRGB system.
+- *
+- * Both these values are reserved (not simple gamma values) in order to allow
+- * more precise correction internally in the future.
+- *
+- * NOTE: the following values can be passed to either the fixed or floating
+- * point APIs, but the floating point API will also accept floating point
+- * values.
++ * how to decode the output values, not how they are encoded.
+ */
+ #define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */
+ #define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */
+@@ -1351,7 +1375,7 @@
+ *
+ * When the default gamma of PNG files doesn't match the output gamma.
+ * If you have PNG files with no gamma information png_set_alpha_mode allows
+- * you to provide a default gamma, but it also sets the output gamma to the
++ * you to provide a default gamma, but it also sets the ouput gamma to the
+ * matching value. If you know your PNG files have a gamma that doesn't
+ * match the output you can take advantage of the fact that
+ * png_set_alpha_mode always sets the output gamma but only sets the PNG
+@@ -1369,51 +1393,50 @@
+ */
+
+ #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+-PNG_EXPORT(36, void, png_set_strip_alpha, (png_structp png_ptr));
++PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+-PNG_EXPORT(37, void, png_set_swap_alpha, (png_structp png_ptr));
++PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+-PNG_EXPORT(38, void, png_set_invert_alpha, (png_structp png_ptr));
++PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+ /* Add a filler byte to 8-bit Gray or 24-bit RGB images. */
+-PNG_EXPORT(39, void, png_set_filler, (png_structp png_ptr, png_uint_32 filler,
++PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler,
+ int flags));
+ /* The values of the PNG_FILLER_ defines should NOT be changed */
+ # define PNG_FILLER_BEFORE 0
+ # define PNG_FILLER_AFTER 1
+ /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
+-PNG_EXPORT(40, void, png_set_add_alpha,
+- (png_structp png_ptr, png_uint_32 filler,
+- int flags));
+-#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */
++PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
++ png_uint_32 filler, int flags));
++#endif /* READ_FILLER || WRITE_FILLER */
+
+ #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+ /* Swap bytes in 16-bit depth files. */
+-PNG_EXPORT(41, void, png_set_swap, (png_structp png_ptr));
++PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+ /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
+-PNG_EXPORT(42, void, png_set_packing, (png_structp png_ptr));
++PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
+ defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+ /* Swap packing order of pixels in bytes. */
+-PNG_EXPORT(43, void, png_set_packswap, (png_structp png_ptr));
++PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+ /* Converts files to legal bit depths. */
+-PNG_EXPORT(44, void, png_set_shift, (png_structp png_ptr, png_const_color_8p
++PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p
+ true_bits));
+ #endif
+
+@@ -1425,12 +1448,12 @@
+ * necessary to call png_read_row or png_read_rows png_get_image_height
+ * times for each pass.
+ */
+-PNG_EXPORT(45, int, png_set_interlace_handling, (png_structp png_ptr));
++PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+ /* Invert monochrome files */
+-PNG_EXPORT(46, void, png_set_invert_mono, (png_structp png_ptr));
++PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_READ_BACKGROUND_SUPPORTED
+@@ -1439,12 +1462,12 @@
+ * read. Doing so will result in unexpected behavior and possible warnings or
+ * errors if the PNG file contains a bKGD chunk.
+ */
+-PNG_FP_EXPORT(47, void, png_set_background, (png_structp png_ptr,
++PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr,
+ png_const_color_16p background_color, int background_gamma_code,
+- int need_expand, double background_gamma));
+-PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structp png_ptr,
++ int need_expand, double background_gamma))
++PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr,
+ png_const_color_16p background_color, int background_gamma_code,
+- int need_expand, png_fixed_point background_gamma));
++ int need_expand, png_fixed_point background_gamma))
+ #endif
+ #ifdef PNG_READ_BACKGROUND_SUPPORTED
+ # define PNG_BACKGROUND_GAMMA_UNKNOWN 0
+@@ -1455,23 +1478,22 @@
+
+ #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+ /* Scale a 16-bit depth file down to 8-bit, accurately. */
+-PNG_EXPORT(229, void, png_set_scale_16, (png_structp png_ptr));
++PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+ #define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */
+ /* Strip the second byte of information from a 16-bit depth file. */
+-PNG_EXPORT(48, void, png_set_strip_16, (png_structp png_ptr));
++PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_READ_QUANTIZE_SUPPORTED
+ /* Turn on quantizing, and reduce the palette to the number of colors
+ * available.
+ */
+-PNG_EXPORT(49, void, png_set_quantize,
+- (png_structp png_ptr, png_colorp palette,
+- int num_palette, int maximum_colors, png_const_uint_16p histogram,
+- int full_quantize));
++PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr,
++ png_colorp palette, int num_palette, int maximum_colors,
++ png_const_uint_16p histogram, int full_quantize));
+ #endif
+
+ #ifdef PNG_READ_GAMMA_SUPPORTED
+@@ -1491,71 +1513,69 @@
+ * API (floating point or fixed.) Notice, however, that the 'file_gamma' value
+ * is the inverse of a 'screen gamma' value.
+ */
+-PNG_FP_EXPORT(50, void, png_set_gamma,
+- (png_structp png_ptr, double screen_gamma,
+- double override_file_gamma));
+-PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structp png_ptr,
+- png_fixed_point screen_gamma, png_fixed_point override_file_gamma));
++PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr,
++ double screen_gamma, double override_file_gamma))
++PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr,
++ png_fixed_point screen_gamma, png_fixed_point override_file_gamma))
+ #endif
+
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+ /* Set how many lines between output flushes - 0 for no flushing */
+-PNG_EXPORT(51, void, png_set_flush, (png_structp png_ptr, int nrows));
++PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows));
+ /* Flush the current PNG output buffer */
+-PNG_EXPORT(52, void, png_write_flush, (png_structp png_ptr));
++PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr));
+ #endif
+
+ /* Optional update palette with requested transformations */
+-PNG_EXPORT(53, void, png_start_read_image, (png_structp png_ptr));
++PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr));
+
+ /* Optional call to update the users info structure */
+-PNG_EXPORT(54, void, png_read_update_info,
+- (png_structp png_ptr, png_infop info_ptr));
++PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr,
++ png_inforp info_ptr));
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read one or more rows of image data. */
+-PNG_EXPORT(55, void, png_read_rows, (png_structp png_ptr, png_bytepp row,
++PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row,
+ png_bytepp display_row, png_uint_32 num_rows));
+ #endif
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read a row of data. */
+-PNG_EXPORT(56, void, png_read_row, (png_structp png_ptr, png_bytep row,
++PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row,
+ png_bytep display_row));
+ #endif
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read the whole image into memory at once. */
+-PNG_EXPORT(57, void, png_read_image, (png_structp png_ptr, png_bytepp image));
++PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image));
+ #endif
+
+ /* Write a row of image data */
+-PNG_EXPORT(58, void, png_write_row,
+- (png_structp png_ptr, png_const_bytep row));
++PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr,
++ png_const_bytep row));
+
+ /* Write a few rows of image data: (*row) is not written; however, the type
+ * is declared as writeable to maintain compatibility with previous versions
+ * of libpng and to allow the 'display_row' array from read_rows to be passed
+ * unchanged to write_rows.
+ */
+-PNG_EXPORT(59, void, png_write_rows, (png_structp png_ptr, png_bytepp row,
++PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row,
+ png_uint_32 num_rows));
+
+ /* Write the image data */
+-PNG_EXPORT(60, void, png_write_image,
+- (png_structp png_ptr, png_bytepp image));
++PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image));
+
+ /* Write the end of the PNG file. */
+-PNG_EXPORT(61, void, png_write_end,
+- (png_structp png_ptr, png_infop info_ptr));
++PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr,
++ png_inforp info_ptr));
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read the end of the PNG file. */
+-PNG_EXPORT(62, void, png_read_end, (png_structp png_ptr, png_infop info_ptr));
++PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr));
+ #endif
+
+ /* Free any memory associated with the png_info_struct */
+-PNG_EXPORT(63, void, png_destroy_info_struct, (png_structp png_ptr,
++PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr,
+ png_infopp info_ptr_ptr));
+
+ /* Free any memory associated with the png_struct and the png_info_structs */
+@@ -1567,8 +1587,8 @@
+ png_infopp info_ptr_ptr));
+
+ /* Set the libpng method of handling chunk CRC errors */
+-PNG_EXPORT(66, void, png_set_crc_action,
+- (png_structp png_ptr, int crit_action, int ancil_action));
++PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
++ int ancil_action));
+
+ /* Values for png_set_crc_action() say how to handle CRC errors in
+ * ancillary and critical chunks, and whether to use the data contained
+@@ -1597,8 +1617,8 @@
+ /* Set the filtering method(s) used by libpng. Currently, the only valid
+ * value for "method" is 0.
+ */
+-PNG_EXPORT(67, void, png_set_filter,
+- (png_structp png_ptr, int method, int filters));
++PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
++ int filters));
+
+ /* Flags for png_set_filter() to say which filters to use. The flags
+ * are chosen so that they don't conflict with real filter types
+@@ -1653,14 +1673,14 @@
+ * the weights and costs are set to 1.0, this degenerates the WEIGHTED method
+ * to the UNWEIGHTED method, but with added encoding time/computation.
+ */
+-PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structp png_ptr,
++PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr,
+ int heuristic_method, int num_weights, png_const_doublep filter_weights,
+- png_const_doublep filter_costs));
++ png_const_doublep filter_costs))
+ PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
+- (png_structp png_ptr,
+- int heuristic_method, int num_weights, png_const_fixed_point_p
+- filter_weights, png_const_fixed_point_p filter_costs));
+-#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
++ (png_structrp png_ptr, int heuristic_method, int num_weights,
++ png_const_fixed_point_p filter_weights,
++ png_const_fixed_point_p filter_costs))
++#endif /* WRITE_WEIGHTED_FILTER */
+
+ /* Heuristic used for row filter selection. These defines should NOT be
+ * changed.
+@@ -1678,45 +1698,45 @@
+ * for PNG images, and do considerably fewer caclulations. In the future,
+ * these values may not correspond directly to the zlib compression levels.
+ */
+-PNG_EXPORT(69, void, png_set_compression_level,
+- (png_structp png_ptr, int level));
+-
+-PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structp png_ptr,
++PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr,
++ int level));
++
++PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr,
+ int mem_level));
+
+-PNG_EXPORT(71, void, png_set_compression_strategy, (png_structp png_ptr,
++PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr,
+ int strategy));
+
+ /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
+ * smaller value of window_bits if it can do so safely.
+ */
+-PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structp png_ptr,
++PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr,
+ int window_bits));
+
+-PNG_EXPORT(73, void, png_set_compression_method, (png_structp png_ptr,
++PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr,
+ int method));
+ #endif
+
+ #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+ /* Also set zlib parameters for compressing non-IDAT chunks */
+-PNG_EXPORT(222, void, png_set_text_compression_level,
+- (png_structp png_ptr, int level));
+-
+-PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structp png_ptr,
++PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr,
++ int level));
++
++PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr,
+ int mem_level));
+
+-PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structp png_ptr,
++PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr,
+ int strategy));
+
+ /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
+ * smaller value of window_bits if it can do so safely.
+ */
+-PNG_EXPORT(225, void, png_set_text_compression_window_bits, (png_structp
+- png_ptr, int window_bits));
+-
+-PNG_EXPORT(226, void, png_set_text_compression_method, (png_structp png_ptr,
++PNG_EXPORT(225, void, png_set_text_compression_window_bits,
++ (png_structrp png_ptr, int window_bits));
++
++PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr,
+ int method));
+-#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */
++#endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
+
+ /* These next functions are called for input/output, memory, and error
+ * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c,
+@@ -1729,7 +1749,7 @@
+
+ #ifdef PNG_STDIO_SUPPORTED
+ /* Initialize the input/output for the PNG file to the default functions. */
+-PNG_EXPORT(74, void, png_init_io, (png_structp png_ptr, png_FILE_p fp));
++PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp));
+ #endif
+
+ /* Replace the (error and abort), and warning functions with user
+@@ -1740,12 +1760,11 @@
+ * default function will be used.
+ */
+
+-PNG_EXPORT(75, void, png_set_error_fn,
+- (png_structp png_ptr, png_voidp error_ptr,
+- png_error_ptr error_fn, png_error_ptr warning_fn));
++PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr,
++ png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
+
+ /* Return the user pointer associated with the error functions */
+-PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structp png_ptr));
++PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr));
+
+ /* Replace the default data output functions with a user supplied one(s).
+ * If buffered output is not used, then output_flush_fn can be set to NULL.
+@@ -1757,47 +1776,47 @@
+ * default flush function, which uses the standard *FILE structure, will
+ * be used.
+ */
+-PNG_EXPORT(77, void, png_set_write_fn, (png_structp png_ptr, png_voidp io_ptr,
++PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr,
+ png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
+
+ /* Replace the default data input function with a user supplied one. */
+-PNG_EXPORT(78, void, png_set_read_fn, (png_structp png_ptr, png_voidp io_ptr,
++PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr,
+ png_rw_ptr read_data_fn));
+
+ /* Return the user pointer associated with the I/O functions */
+-PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_structp png_ptr));
+-
+-PNG_EXPORT(80, void, png_set_read_status_fn, (png_structp png_ptr,
++PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr));
++
++PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr,
+ png_read_status_ptr read_row_fn));
+
+-PNG_EXPORT(81, void, png_set_write_status_fn, (png_structp png_ptr,
++PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr,
+ png_write_status_ptr write_row_fn));
+
+ #ifdef PNG_USER_MEM_SUPPORTED
+ /* Replace the default memory allocation functions with user supplied one(s). */
+-PNG_EXPORT(82, void, png_set_mem_fn, (png_structp png_ptr, png_voidp mem_ptr,
++PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+ /* Return the user pointer associated with the memory functions */
+-PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structp png_ptr));
++PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+-PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structp png_ptr,
++PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr,
+ png_user_transform_ptr read_user_transform_fn));
+ #endif
+
+ #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+-PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structp png_ptr,
++PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr,
+ png_user_transform_ptr write_user_transform_fn));
+ #endif
+
+ #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+-PNG_EXPORT(86, void, png_set_user_transform_info, (png_structp png_ptr,
++PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr,
+ png_voidp user_transform_ptr, int user_transform_depth,
+ int user_transform_channels));
+ /* Return the user pointer associated with the user transform functions */
+ PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
+@@ -1812,31 +1831,53 @@
+ * find the output pixel (x,y) given an interlaced sub-image pixel
+ * (row,col,pass). (See below for these macros.)
+ */
+-PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structp));
+-PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structp));
++PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp));
++PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp));
+ #endif
+
++#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
++/* This callback is called only for *unknown* chunks. If
++ * PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known
++ * chunks to be treated as unknown, however in this case the callback must do
++ * any processing required by the chunk (e.g. by calling the appropriate
++ * png_set_ APIs.)
++ *
++ * There is no write support - on write, by default, all the chunks in the
++ * 'unknown' list are written in the specified position.
++ *
++ * The integer return from the callback function is interpreted thus:
++ *
++ * negative: An error occured, png_chunk_error will be called.
++ * zero: The chunk was not handled, the chunk will be saved. A critical
++ * chunk will cause an error at this point unless it is to be saved.
++ * positive: The chunk was handled, libpng will ignore/discard it.
++ *
++ * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about
++ * how this behavior will change in libpng 1.7
++ */
++PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
++ png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
++#endif
++
+ #ifdef PNG_USER_CHUNKS_SUPPORTED
+-PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structp png_ptr,
+- png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
+-PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structp png_ptr));
++PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr));
+ #endif
+
+ #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+ /* Sets the function callbacks for the push reader, and a pointer to a
+ * user-defined structure available to the callback functions.
+ */
+-PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structp png_ptr,
++PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr,
+ png_voidp progressive_ptr, png_progressive_info_ptr info_fn,
+ png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn));
+
+ /* Returns the user pointer associated with the push read functions */
+-PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, (png_const_structp png_ptr));
++PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
++ (png_const_structrp png_ptr));
+
+ /* Function to be called when data becomes available */
+-PNG_EXPORT(92, void, png_process_data,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_bytep buffer, png_size_t buffer_size));
++PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
++ png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size));
+
+ /* A function which may be called *only* within png_process_data to stop the
+ * processing of any more data. The function returns the number of bytes
+@@ -1845,7 +1886,7 @@
+ * 'save' is set to true the routine will first save all the pending data and
+ * will always return 0.
+ */
+-PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structp, int save));
++PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save));
+
+ /* A function which may be called *only* outside (after) a call to
+ * png_process_data. It returns the number of bytes of data to skip in the
+@@ -1853,40 +1894,43 @@
+ * application must skip than number of bytes of input data and pass the
+ * following data to the next call to png_process_data.
+ */
+-PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structp));
++PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
+
+ /* Function that combines rows. 'new_row' is a flag that should come from
+ * the callback and be non-NULL if anything needs to be done; the library
+ * stores its own version of the new data internally and ignores the passed
+ * in value.
+ */
+-PNG_EXPORT(93, void, png_progressive_combine_row, (png_structp png_ptr,
++PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
+ png_bytep old_row, png_const_bytep new_row));
+-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+-
+-PNG_EXPORTA(94, png_voidp, png_malloc,
+- (png_structp png_ptr, png_alloc_size_t size),
+- PNG_ALLOCATED);
++#endif /* PROGRESSIVE_READ */
++
++PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr,
++ png_alloc_size_t size), PNG_ALLOCATED);
+ /* Added at libpng version 1.4.0 */
+-PNG_EXPORTA(95, png_voidp, png_calloc,
+- (png_structp png_ptr, png_alloc_size_t size),
+- PNG_ALLOCATED);
++PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr,
++ png_alloc_size_t size), PNG_ALLOCATED);
+
+ /* Added at libpng version 1.2.4 */
+-PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_structp png_ptr,
++PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr,
+ png_alloc_size_t size), PNG_ALLOCATED);
+
+ /* Frees a pointer allocated by png_malloc() */
+-PNG_EXPORT(97, void, png_free, (png_structp png_ptr, png_voidp ptr));
++PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr));
+
+ /* Free data that was allocated internally */
+-PNG_EXPORT(98, void, png_free_data,
+- (png_structp png_ptr, png_infop info_ptr, png_uint_32 free_me, int num));
++PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 free_me, int num));
+
+ /* Reassign responsibility for freeing existing data, whether allocated
+- * by libpng or by the application */
+-PNG_EXPORT(99, void, png_data_freer,
+- (png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask));
++ * by libpng or by the application; this works on the png_info structure passed
++ * in, it does not change the state for other png_info structures.
++ *
++ * It is unlikely that this function works correctly as of 1.6.0 and using it
++ * may result either in memory leaks or double free of allocated data.
++ */
++PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
++ png_inforp info_ptr, int freer, png_uint_32 mask));
+
+ /* Assignments for png_data_freer */
+ #define PNG_DESTROY_WILL_FREE_DATA 1
+@@ -1899,8 +1943,10 @@
+ #define PNG_FREE_ROWS 0x0040
+ #define PNG_FREE_PCAL 0x0080
+ #define PNG_FREE_SCAL 0x0100
+-#define PNG_FREE_UNKN 0x0200
+-#define PNG_FREE_LIST 0x0400
++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
++# define PNG_FREE_UNKN 0x0200
++#endif
++/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */
+ #define PNG_FREE_PLTE 0x1000
+ #define PNG_FREE_TRNS 0x2000
+ #define PNG_FREE_TEXT 0x4000
+@@ -1908,50 +1954,55 @@
+ #define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
+
+ #ifdef PNG_USER_MEM_SUPPORTED
+-PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_structp png_ptr,
+- png_alloc_size_t size), PNG_ALLOCATED);
+-PNG_EXPORT(101, void, png_free_default, (png_structp png_ptr, png_voidp ptr));
++PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
++ png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED);
++PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
++ png_voidp ptr), PNG_DEPRECATED);
+ #endif
+
+ #ifdef PNG_ERROR_TEXT_SUPPORTED
+ /* Fatal error in PNG image of libpng - can't continue */
+-PNG_EXPORTA(102, void, png_error,
+- (png_structp png_ptr, png_const_charp error_message),
+- PNG_NORETURN);
++PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr,
++ png_const_charp error_message), PNG_NORETURN);
+
+ /* The same, but the chunk name is prepended to the error string. */
+-PNG_EXPORTA(103, void, png_chunk_error, (png_structp png_ptr,
++PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr,
+ png_const_charp error_message), PNG_NORETURN);
+
+ #else
+ /* Fatal error in PNG image of libpng - can't continue */
+-PNG_EXPORTA(104, void, png_err, (png_structp png_ptr), PNG_NORETURN);
++PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN);
++# define png_error(s1,s2) png_err(s1)
++# define png_chunk_error(s1,s2) png_err(s1)
+ #endif
+
+ #ifdef PNG_WARNINGS_SUPPORTED
+ /* Non-fatal error in libpng. Can continue, but may have a problem. */
+-PNG_EXPORT(105, void, png_warning, (png_structp png_ptr,
++PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr,
+ png_const_charp warning_message));
+
+ /* Non-fatal error in libpng, chunk name is prepended to message. */
+-PNG_EXPORT(106, void, png_chunk_warning, (png_structp png_ptr,
++PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr,
+ png_const_charp warning_message));
++#else
++# define png_warning(s1,s2) ((void)(s1))
++# define png_chunk_warning(s1,s2) ((void)(s1))
+ #endif
+
+ #ifdef PNG_BENIGN_ERRORS_SUPPORTED
+ /* Benign error in libpng. Can continue, but may have a problem.
+ * User can choose whether to handle as a fatal error or as a warning. */
+-# undef png_benign_error
+-PNG_EXPORT(107, void, png_benign_error, (png_structp png_ptr,
++PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr,
+ png_const_charp warning_message));
+
+-/* Same, chunk name is prepended to message. */
+-# undef png_chunk_benign_error
+-PNG_EXPORT(108, void, png_chunk_benign_error, (png_structp png_ptr,
++#ifdef PNG_READ_SUPPORTED
++/* Same, chunk name is prepended to message (only during read) */
++PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr,
+ png_const_charp warning_message));
++#endif
+
+ PNG_EXPORT(109, void, png_set_benign_errors,
+- (png_structp png_ptr, int allowed));
++ (png_structrp png_ptr, int allowed));
+ #else
+ # ifdef PNG_ALLOW_BENIGN_ERRORS
+ # define png_benign_error png_warning
+@@ -1975,268 +2026,274 @@
+ * png_info_struct.
+ */
+ /* Returns "flag" if chunk data is valid in info_ptr. */
+-PNG_EXPORT(110, png_uint_32, png_get_valid,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_uint_32 flag));
++PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, png_uint_32 flag));
+
+ /* Returns number of bytes needed to hold a transformed row. */
+-PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ #ifdef PNG_INFO_IMAGE_SUPPORTED
+ /* Returns row_pointers, which is an array of pointers to scanlines that was
+ * returned from png_read_png().
+ */
+-PNG_EXPORT(112, png_bytepp, png_get_rows,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
++
+ /* Set row_pointers, which is an array of pointers to scanlines for use
+ * by png_write_png().
+ */
+-PNG_EXPORT(113, void, png_set_rows, (png_structp png_ptr,
+- png_infop info_ptr, png_bytepp row_pointers));
++PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_bytepp row_pointers));
+ #endif
+
+ /* Returns number of color channels in image. */
+-PNG_EXPORT(114, png_byte, png_get_channels,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ #ifdef PNG_EASY_ACCESS_SUPPORTED
+ /* Returns image width in pixels. */
+-PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ /* Returns image height in pixels. */
+-PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ /* Returns image bit_depth. */
+-PNG_EXPORT(117, png_byte, png_get_bit_depth,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ /* Returns image color_type. */
+-PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ /* Returns image filter_type. */
+-PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ /* Returns image interlace_type. */
+-PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ /* Returns image compression_type. */
+-PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
+
+ /* Returns image resolution in pixels per meter, from pHYs chunk data. */
+ PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+ PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+ PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+ /* Returns pixel aspect ratio, computed from pHYs chunk data. */
+ PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr))
+ PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr))
+
+ /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
+ PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+ PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+ PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+ PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
+-
+-#endif /* PNG_EASY_ACCESS_SUPPORTED */
+-
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
++
++#endif /* EASY_ACCESS */
++
++#ifdef PNG_READ_SUPPORTED
+ /* Returns pointer to signature string read from PNG header */
+-PNG_EXPORT(130, png_const_bytep, png_get_signature,
+- (png_const_structp png_ptr, png_infop info_ptr));
++PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr));
++#endif
+
+ #ifdef PNG_bKGD_SUPPORTED
+-PNG_EXPORT(131, png_uint_32, png_get_bKGD,
+- (png_const_structp png_ptr, png_infop info_ptr,
+- png_color_16p *background));
++PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_color_16p *background));
+ #endif
+
+ #ifdef PNG_bKGD_SUPPORTED
+-PNG_EXPORT(132, void, png_set_bKGD, (png_structp png_ptr, png_infop info_ptr,
+- png_const_color_16p background));
++PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_color_16p background));
+ #endif
+
+ #ifdef PNG_cHRM_SUPPORTED
+-PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structp png_ptr,
+- png_const_infop info_ptr, double *white_x, double *white_y, double *red_x,
++PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x,
+ double *red_y, double *green_x, double *green_y, double *blue_x,
+- double *blue_y));
+-#ifdef PNG_FIXED_POINT_SUPPORTED /* Otherwise not implemented */
++ double *blue_y))
++PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z,
++ double *green_X, double *green_Y, double *green_Z, double *blue_X,
++ double *blue_Y, double *blue_Z))
+ PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed,
+- (png_const_structp png_ptr,
+- png_const_infop info_ptr, png_fixed_point *int_white_x,
+- png_fixed_point *int_white_y, png_fixed_point *int_red_x,
+- png_fixed_point *int_red_y, png_fixed_point *int_green_x,
+- png_fixed_point *int_green_y, png_fixed_point *int_blue_x,
+- png_fixed_point *int_blue_y));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr,
++ png_fixed_point *int_white_x, png_fixed_point *int_white_y,
++ png_fixed_point *int_red_x, png_fixed_point *int_red_y,
++ png_fixed_point *int_green_x, png_fixed_point *int_green_y,
++ png_fixed_point *int_blue_x, png_fixed_point *int_blue_y))
++PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed,
++ (png_const_structrp png_ptr, png_const_inforp info_ptr,
++ png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
++ png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
++ png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
++ png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
++ png_fixed_point *int_blue_Z))
+ #endif
+-#endif
+
+ #ifdef PNG_cHRM_SUPPORTED
+-PNG_FP_EXPORT(135, void, png_set_cHRM,
+- (png_structp png_ptr, png_infop info_ptr,
++PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr,
++ png_inforp info_ptr,
+ double white_x, double white_y, double red_x, double red_y, double green_x,
+- double green_y, double blue_x, double blue_y));
+-PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_structp png_ptr,
+- png_infop info_ptr, png_fixed_point int_white_x,
++ double green_y, double blue_x, double blue_y))
++PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr,
++ png_inforp info_ptr, double red_X, double red_Y, double red_Z,
++ double green_X, double green_Y, double green_Z, double blue_X,
++ double blue_Y, double blue_Z))
++PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_fixed_point int_white_x,
+ png_fixed_point int_white_y, png_fixed_point int_red_x,
+ png_fixed_point int_red_y, png_fixed_point int_green_x,
+ png_fixed_point int_green_y, png_fixed_point int_blue_x,
+- png_fixed_point int_blue_y));
++ png_fixed_point int_blue_y))
++PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y,
++ png_fixed_point int_red_Z, png_fixed_point int_green_X,
++ png_fixed_point int_green_Y, png_fixed_point int_green_Z,
++ png_fixed_point int_blue_X, png_fixed_point int_blue_Y,
++ png_fixed_point int_blue_Z))
+ #endif
+
+ #ifdef PNG_gAMA_SUPPORTED
+-PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- double *file_gamma));
++PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, double *file_gamma))
+ PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_fixed_point *int_file_gamma));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr,
++ png_fixed_point *int_file_gamma))
+ #endif
+
+ #ifdef PNG_gAMA_SUPPORTED
+-PNG_FP_EXPORT(139, void, png_set_gAMA, (png_structp png_ptr,
+- png_infop info_ptr, double file_gamma));
+-PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_structp png_ptr,
+- png_infop info_ptr, png_fixed_point int_file_gamma));
++PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr,
++ png_inforp info_ptr, double file_gamma))
++PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_fixed_point int_file_gamma))
+ #endif
+
+ #ifdef PNG_hIST_SUPPORTED
+-PNG_EXPORT(141, png_uint_32, png_get_hIST,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_uint_16p *hist));
++PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_uint_16p *hist));
+ #endif
+
+ #ifdef PNG_hIST_SUPPORTED
+-PNG_EXPORT(142, void, png_set_hIST, (png_structp png_ptr,
+- png_infop info_ptr, png_const_uint_16p hist));
++PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_uint_16p hist));
+ #endif
+
+-PNG_EXPORT(143, png_uint_32, png_get_IHDR,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type,
+- int *interlace_method, int *compression_method, int *filter_method));
+-
+-PNG_EXPORT(144, void, png_set_IHDR,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 width, png_uint_32 height, int bit_depth, int color_type,
+- int interlace_method, int compression_method, int filter_method));
++PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height,
++ int *bit_depth, int *color_type, int *interlace_method,
++ int *compression_method, int *filter_method));
++
++PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,
++ int color_type, int interlace_method, int compression_method,
++ int filter_method));
+
+ #ifdef PNG_oFFs_SUPPORTED
+-PNG_EXPORT(145, png_uint_32, png_get_oFFs,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type));
++PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
++ int *unit_type));
+ #endif
+
+ #ifdef PNG_oFFs_SUPPORTED
+-PNG_EXPORT(146, void, png_set_oFFs,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_int_32 offset_x, png_int_32 offset_y, int unit_type));
++PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y,
++ int unit_type));
+ #endif
+
+ #ifdef PNG_pCAL_SUPPORTED
+-PNG_EXPORT(147, png_uint_32, png_get_pCAL,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type,
+- int *nparams,
+- png_charp *units, png_charpp *params));
++PNG_EXPORT(147, png_uint_32, 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));
+ #endif
+
+ #ifdef PNG_pCAL_SUPPORTED
+-PNG_EXPORT(148, void, png_set_pCAL, (png_structp png_ptr,
+- png_infop info_ptr,
+- png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type,
+- int nparams, png_const_charp units, png_charpp params));
++PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1,
++ int type, int nparams, png_const_charp units, png_charpp params));
+ #endif
+
+ #ifdef PNG_pHYs_SUPPORTED
+-PNG_EXPORT(149, png_uint_32, png_get_pHYs,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
++PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
++ int *unit_type));
+ #endif
+
+ #ifdef PNG_pHYs_SUPPORTED
+-PNG_EXPORT(150, void, png_set_pHYs,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 res_x, png_uint_32 res_y, int unit_type));
++PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
+ #endif
+
+-PNG_EXPORT(151, png_uint_32, png_get_PLTE,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_colorp *palette, int *num_palette));
+-
+-PNG_EXPORT(152, void, png_set_PLTE,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_const_colorp palette, int num_palette));
++PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr,
++ 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));
+
+ #ifdef PNG_sBIT_SUPPORTED
+-PNG_EXPORT(153, png_uint_32, png_get_sBIT,
+- (png_const_structp png_ptr, png_infop info_ptr,
+- png_color_8p *sig_bit));
++PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_color_8p *sig_bit));
+ #endif
+
+ #ifdef PNG_sBIT_SUPPORTED
+-PNG_EXPORT(154, void, png_set_sBIT,
+- (png_structp png_ptr, png_infop info_ptr, png_const_color_8p sig_bit));
++PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_color_8p sig_bit));
+ #endif
+
+ #ifdef PNG_sRGB_SUPPORTED
+-PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structp png_ptr,
+- png_const_infop info_ptr, int *file_srgb_intent));
++PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, int *file_srgb_intent));
+ #endif
+
+ #ifdef PNG_sRGB_SUPPORTED
+-PNG_EXPORT(156, void, png_set_sRGB,
+- (png_structp png_ptr, png_infop info_ptr, int srgb_intent));
+-PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_structp png_ptr,
+- png_infop info_ptr, int srgb_intent));
++PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr,
++ png_inforp info_ptr, int srgb_intent));
++PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr,
++ png_inforp info_ptr, int srgb_intent));
+ #endif
+
+ #ifdef PNG_iCCP_SUPPORTED
+-PNG_EXPORT(158, png_uint_32, png_get_iCCP,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- png_charpp name, int *compression_type, png_bytepp profile,
+- png_uint_32 *proflen));
++PNG_EXPORT(158, png_uint_32, 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));
+ #endif
+
+ #ifdef PNG_iCCP_SUPPORTED
+-PNG_EXPORT(159, void, png_set_iCCP,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_const_charp name, int compression_type, png_const_bytep profile,
+- png_uint_32 proflen));
++PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_charp name, int compression_type,
++ png_const_bytep profile, png_uint_32 proflen));
+ #endif
+
+ #ifdef PNG_sPLT_SUPPORTED
+-PNG_EXPORT(160, png_uint_32, png_get_sPLT,
+- (png_const_structp png_ptr, png_const_infop 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
+-PNG_EXPORT(161, void, png_set_sPLT,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_const_sPLT_tp entries, int nentries));
++PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_sPLT_tp entries, int nentries));
+ #endif
+
+ #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_structp png_ptr, png_const_infop 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,
+@@ -2247,116 +2304,220 @@
+ */
+
+ #ifdef PNG_TEXT_SUPPORTED
+-PNG_EXPORT(163, void, png_set_text,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_const_textp text_ptr, int num_text));
++PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_textp text_ptr, int num_text));
+ #endif
+
+ #ifdef PNG_tIME_SUPPORTED
+-PNG_EXPORT(164, png_uint_32, png_get_tIME,
+- (png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time));
++PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_timep *mod_time));
+ #endif
+
+ #ifdef PNG_tIME_SUPPORTED
+-PNG_EXPORT(165, void, png_set_tIME,
+- (png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time));
++PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_timep mod_time));
+ #endif
+
+ #ifdef PNG_tRNS_SUPPORTED
+-PNG_EXPORT(166, png_uint_32, png_get_tRNS,
+- (png_const_structp png_ptr, png_infop info_ptr,
+- png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color));
++PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans,
++ png_color_16p *trans_color));
+ #endif
+
+ #ifdef PNG_tRNS_SUPPORTED
+-PNG_EXPORT(167, void, png_set_tRNS,
+- (png_structp png_ptr, png_infop info_ptr,
+- png_const_bytep trans_alpha, int num_trans,
++PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr,
++ png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans,
+ png_const_color_16p trans_color));
+ #endif
+
+ #ifdef PNG_sCAL_SUPPORTED
+-PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- int *unit, double *width, double *height));
+-#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
++PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, int *unit, double *width, double *height))
++#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
++ defined(PNG_FLOATING_POINT_SUPPORTED)
+ /* NOTE: this API is currently implemented using floating point arithmetic,
+ * consequently it can only be used on systems with floating point support.
+ * In any case the range of values supported by png_fixed_point is small and it
+ * is highly recommended that png_get_sCAL_s be used instead.
+ */
+ PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed,
+- (png_structp png_ptr, png_const_infop info_ptr, int *unit,
+- png_fixed_point *width,
+- png_fixed_point *height));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
++ png_fixed_point *width, png_fixed_point *height))
+ #endif
+ PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
+- (png_const_structp png_ptr, png_const_infop info_ptr,
+- int *unit, png_charpp swidth, png_charpp sheight));
+-
+-PNG_FP_EXPORT(170, void, png_set_sCAL,
+- (png_structp png_ptr, png_infop info_ptr,
+- int unit, double width, double height));
+-PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_structp png_ptr,
+- png_infop info_ptr, int unit, png_fixed_point width,
+- png_fixed_point height));
+-PNG_EXPORT(171, void, png_set_sCAL_s,
+- (png_structp png_ptr, png_infop info_ptr,
+- int unit, png_const_charp swidth, png_const_charp sheight));
+-#endif /* PNG_sCAL_SUPPORTED */
+-
+-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+-/* Provide a list of chunks and how they are to be handled, if the built-in
+- handling or default unknown chunk handling is not desired. Any chunks not
+- listed will be handled in the default manner. The IHDR and IEND chunks
+- must not be listed.
+- keep = 0: follow default behaviour
+- = 1: do not keep
+- = 2: keep only if safe-to-copy
+- = 3: keep even if unsafe-to-copy
+-*/
+-PNG_EXPORT(172, void, png_set_keep_unknown_chunks,
+- (png_structp png_ptr, int keep,
+- png_const_bytep chunk_list, int num_chunks));
+-PNG_EXPORT(173, int, png_handle_as_unknown, (png_structp png_ptr,
++ (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
++ png_charpp swidth, png_charpp sheight));
++
++PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr,
++ png_inforp info_ptr, int unit, double width, double height))
++PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr,
++ png_inforp info_ptr, int unit, png_fixed_point width,
++ png_fixed_point height))
++PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
++ png_inforp info_ptr, int unit,
++ png_const_charp swidth, png_const_charp sheight));
++#endif /* sCAL */
++
++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++/* Provide the default handling for all unknown chunks or, optionally, for
++ * specific unknown chunks.
++ *
++ * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was
++ * ignored and the default was used, the per-chunk setting only had an effect on
++ * write. If you wish to have chunk-specific handling on read in code that must
++ * work on earlier versions you must use a user chunk callback to specify the
++ * desired handling (keep or discard.)
++ *
++ * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below. The
++ * parameter is interpreted as follows:
++ *
++ * READ:
++ * PNG_HANDLE_CHUNK_AS_DEFAULT:
++ * Known chunks: do normal libpng processing, do not keep the chunk (but
++ * see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
++ * Unknown chunks: for a specific chunk use the global default, when used
++ * as the default discard the chunk data.
++ * PNG_HANDLE_CHUNK_NEVER:
++ * Discard the chunk data.
++ * PNG_HANDLE_CHUNK_IF_SAFE:
++ * Keep the chunk data if the chunk is not critical else raise a chunk
++ * error.
++ * PNG_HANDLE_CHUNK_ALWAYS:
++ * Keep the chunk data.
++ *
++ * If the chunk data is saved it can be retrieved using png_get_unknown_chunks,
++ * below. Notice that specifying "AS_DEFAULT" as a global default is equivalent
++ * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks
++ * it simply resets the behavior to the libpng default.
++ *
++ * INTERACTION WTIH USER CHUNK CALLBACKS:
++ * The per-chunk handling is always used when there is a png_user_chunk_ptr
++ * callback and the callback returns 0; the chunk is then always stored *unless*
++ * it is critical and the per-chunk setting is other than ALWAYS. Notice that
++ * the global default is *not* used in this case. (In effect the per-chunk
++ * value is incremented to at least IF_SAFE.)
++ *
++ * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and
++ * per-chunk defaults will be honored. If you want to preserve the current
++ * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE
++ * as the default - if you don't do this libpng 1.6 will issue a warning.
++ *
++ * If you want unhandled unknown chunks to be discarded in libpng 1.6 and
++ * earlier simply return '1' (handled).
++ *
++ * PNG_HANDLE_AS_UNKNOWN_SUPPORTED:
++ * If this is *not* set known chunks will always be handled by libpng and
++ * will never be stored in the unknown chunk list. Known chunks listed to
++ * png_set_keep_unknown_chunks will have no effect. If it is set then known
++ * chunks listed with a keep other than AS_DEFAULT will *never* be processed
++ * by libpng, in addition critical chunks must either be processed by the
++ * callback or saved.
++ *
++ * The IHDR and IEND chunks must not be listed. Because this turns off the
++ * default handling for chunks that would otherwise be recognized the
++ * behavior of libpng transformations may well become incorrect!
++ *
++ * WRITE:
++ * When writing chunks the options only apply to the chunks specified by
++ * png_set_unknown_chunks (below), libpng will *always* write known chunks
++ * required by png_set_ calls and will always write the core critical chunks
++ * (as required for PLTE).
++ *
++ * Each chunk in the png_set_unknown_chunks list is looked up in the
++ * png_set_keep_unknown_chunks list to find the keep setting, this is then
++ * interpreted as follows:
++ *
++ * PNG_HANDLE_CHUNK_AS_DEFAULT:
++ * Write safe-to-copy chunks and write other chunks if the global
++ * default is set to _ALWAYS, otherwise don't write this chunk.
++ * PNG_HANDLE_CHUNK_NEVER:
++ * Do not write the chunk.
++ * PNG_HANDLE_CHUNK_IF_SAFE:
++ * Write the chunk if it is safe-to-copy, otherwise do not write it.
++ * PNG_HANDLE_CHUNK_ALWAYS:
++ * Write the chunk.
++ *
++ * Note that the default behavior is effectively the opposite of the read case -
++ * in read unknown chunks are not stored by default, in write they are written
++ * by default. Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different
++ * - on write the safe-to-copy bit is checked, on read the critical bit is
++ * checked and on read if the chunk is critical an error will be raised.
++ *
++ * num_chunks:
++ * ===========
++ * If num_chunks is positive, then the "keep" parameter specifies the manner
++ * for handling only those chunks appearing in the chunk_list array,
++ * otherwise the chunk list array is ignored.
++ *
++ * If num_chunks is 0 the "keep" parameter specifies the default behavior for
++ * unknown chunks, as described above.
++ *
++ * If num_chunks is negative, then the "keep" parameter specifies the manner
++ * for handling all unknown chunks plus all chunks recognized by libpng
++ * except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to
++ * be processed by libpng.
++ */
++PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
++ int keep, png_const_bytep chunk_list, int num_chunks));
++
++/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned;
++ * the result is therefore true (non-zero) if special handling is required,
++ * false for the default handling.
++ */
++PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
+ png_const_bytep chunk_name));
+ #endif
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+-PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structp png_ptr,
+- png_infop info_ptr, png_const_unknown_chunkp unknowns,
++
++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
++PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_unknown_chunkp unknowns,
+ int num_unknowns));
++ /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added
++ * unknowns to the location currently stored in the png_struct. This is
++ * invariably the wrong value on write. To fix this call the following API
++ * for each chunk in the list with the correct location. If you know your
++ * code won't be compiled on earlier versions you can rely on
++ * png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing
++ * the correct thing.
++ */
++
+ PNG_EXPORT(175, void, png_set_unknown_chunk_location,
+- (png_structp png_ptr, png_infop info_ptr, int chunk, int location));
+-PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structp png_ptr,
+- png_const_infop info_ptr, png_unknown_chunkpp entries));
++ (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_inforp info_ptr, png_unknown_chunkpp entries));
+ #endif
+
+ /* Png_free_data() will turn off the "valid" flag for anything it frees.
+ * If you need to turn it off for a chunk that your application has freed,
+ * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);
+ */
+-PNG_EXPORT(177, void, png_set_invalid,
+- (png_structp png_ptr, png_infop info_ptr, int mask));
++PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr,
++ png_inforp info_ptr, int mask));
+
+ #ifdef PNG_INFO_IMAGE_SUPPORTED
+ /* The "params" pointer is currently not used and is for future expansion. */
+-PNG_EXPORT(178, void, png_read_png, (png_structp png_ptr, png_infop info_ptr,
+- int transforms, png_voidp params));
+-PNG_EXPORT(179, void, png_write_png, (png_structp png_ptr, png_infop info_ptr,
++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr,
+ int transforms, png_voidp params));
+ #endif
++#ifdef PNG_WRITE_SUPPORTED
++PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr,
++ int transforms, png_voidp params));
++#endif
++#endif
+
+ PNG_EXPORT(180, png_const_charp, png_get_copyright,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ PNG_EXPORT(181, png_const_charp, png_get_header_ver,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ PNG_EXPORT(182, png_const_charp, png_get_header_version,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ PNG_EXPORT(183, png_const_charp, png_get_libpng_ver,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+-PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structp png_ptr,
++PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr,
+ png_uint_32 mng_features_permitted));
+ #endif
+
+@@ -2365,75 +2526,77 @@
+ #define PNG_HANDLE_CHUNK_NEVER 1
+ #define PNG_HANDLE_CHUNK_IF_SAFE 2
+ #define PNG_HANDLE_CHUNK_ALWAYS 3
++#define PNG_HANDLE_CHUNK_LAST 4
+
+ /* Strip the prepended error numbers ("#nnn ") from error and warning
+ * messages before passing them to the error or warning handler.
+ */
+ #ifdef PNG_ERROR_NUMBERS_SUPPORTED
+-PNG_EXPORT(185, void, png_set_strip_error_numbers,
+- (png_structp png_ptr,
++PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr,
+ png_uint_32 strip_mode));
+ #endif
+
+ /* Added in libpng-1.2.6 */
+ #ifdef PNG_SET_USER_LIMITS_SUPPORTED
+-PNG_EXPORT(186, void, png_set_user_limits, (png_structp png_ptr,
++PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr,
+ png_uint_32 user_width_max, png_uint_32 user_height_max));
+ PNG_EXPORT(187, png_uint_32, png_get_user_width_max,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ PNG_EXPORT(188, png_uint_32, png_get_user_height_max,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ /* Added in libpng-1.4.0 */
+-PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structp png_ptr,
++PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr,
+ png_uint_32 user_chunk_cache_max));
+ PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ /* Added in libpng-1.4.1 */
+-PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structp png_ptr,
++PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr,
+ png_alloc_size_t user_chunk_cache_max));
+ PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+ #endif
+
+ #if defined(PNG_INCH_CONVERSIONS_SUPPORTED)
+ PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+ PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+ PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+ PNG_FP_EXPORT(196, float, png_get_x_offset_inches,
+- (png_const_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr))
+ #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
+ PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed,
+- (png_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr))
+ #endif
+
+-PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structp png_ptr,
+- png_const_infop info_ptr));
++PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr))
+ #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
+ PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed,
+- (png_structp png_ptr, png_const_infop info_ptr));
++ (png_const_structrp png_ptr, png_const_inforp info_ptr))
+ #endif
+
+ # ifdef PNG_pHYs_SUPPORTED
+-PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structp png_ptr,
+- png_const_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
++PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr,
++ png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
+ int *unit_type));
+-# endif /* PNG_pHYs_SUPPORTED */
+-#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */
++# endif /* pHYs */
++#endif /* INCH_CONVERSIONS */
+
+ /* Added in libpng-1.4.0 */
+ #ifdef PNG_IO_STATE_SUPPORTED
+-PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_structp png_ptr));
+-
+-PNG_EXPORTA(200, png_const_bytep, png_get_io_chunk_name,
+- (png_structp png_ptr), PNG_DEPRECATED);
++PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr));
++
++/* Removed from libpng 1.6; use png_get_io_chunk_type. */
++PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr),
++ PNG_DEPRECATED)
++
+ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
+- (png_const_structp png_ptr));
++ (png_const_structrp png_ptr));
+
+ /* The flags returned by png_get_io_state() are the following: */
+ # define PNG_IO_NONE 0x0000 /* no I/O at this moment */
+@@ -2445,7 +2608,7 @@
+ # define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */
+ # define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */
+ # define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */
+-#endif /* ?PNG_IO_STATE_SUPPORTED */
++#endif /* IO_STATE */
+
+ /* Interlace support. The following macros are always defined so that if
+ * libpng interlace handling is turned off the macros may be used to handle
+@@ -2457,8 +2620,16 @@
+ * full, image which appears in a given pass. 'pass' is in the range 0
+ * to 6 and the result is in the range 0 to 7.
+ */
+-#define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7)
+-#define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7)
++#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7)
++#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)
++
++/* A macro to return the offset between pixels in the output row for a pair of
++ * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that
++ * follows. Note that ROW_OFFSET is the offset from one row to the next whereas
++ * COL_OFFSET is from one column to the next, within a row.
++ */
++#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8)
++#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1))
+
+ /* Two macros to help evaluate the number of rows or columns in each
+ * pass. This is expressed as a shift - effectively log2 of the number or
+@@ -2481,10 +2652,10 @@
+ * necessary to find the row in the output image given a row in an interlaced
+ * image, so two more macros:
+ */
+-#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \
+- (((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
+-#define PNG_COL_FROM_PASS_COL(xIn, pass) \
+- (((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
++#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \
++ (((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
++#define PNG_COL_FROM_PASS_COL(x_in, pass) \
++ (((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
+
+ /* Two macros which return a boolean (0 or 1) saying whether the given row
+ * or column is in a particular pass. These use a common utility macro that
+@@ -2493,8 +2664,8 @@
+ * the tile.
+ */
+ #define PNG_PASS_MASK(pass,off) ( \
+- ((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \
+- ((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U))
++ ((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | \
++ ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0))
+
+ #define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
+ ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
+@@ -2520,14 +2691,14 @@
+ { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
+ * (png_uint_16)(alpha) \
+ + (png_uint_16)(bg)*(png_uint_16)(255 \
+- - (png_uint_16)(alpha)) + (png_uint_16)128); \
++ - (png_uint_16)(alpha)) + 128); \
+ (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
+
+ # define png_composite_16(composite, fg, alpha, bg) \
+ { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
+ * (png_uint_32)(alpha) \
+- + (png_uint_32)(bg)*(png_uint_32)(65535L \
+- - (png_uint_32)(alpha)) + (png_uint_32)32768L); \
++ + (png_uint_32)(bg)*(65535 \
++ - (png_uint_32)(alpha)) + 32768); \
+ (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
+
+ #else /* Standard method using integer division */
+@@ -2535,13 +2706,13 @@
+ # define png_composite(composite, fg, alpha, bg) \
+ (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \
+ (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
+- (png_uint_16)127) / 255)
++ 127) / 255)
+
+ # define png_composite_16(composite, fg, alpha, bg) \
+ (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
+- (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \
+- (png_uint_32)32767) / (png_uint_32)65535L)
+-#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */
++ (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
++ 32767) / 65535)
++#endif /* READ_COMPOSITE_NODIV */
+
+ #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
+ PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf));
+@@ -2549,7 +2720,7 @@
+ PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf));
+ #endif
+
+-PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_structp png_ptr,
++PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr,
+ png_const_bytep buf));
+ /* No png_get_int_16 -- may be added if there's a real need for it. */
+
+@@ -2575,7 +2746,7 @@
+ * The png_get_int_32() routine assumes we are using two's complement
+ * format for negative values, which is almost certainly true.
+ */
+-# define png_get_uint_32(buf) \
++# define PNG_get_uint_32(buf) \
+ (((png_uint_32)(*(buf)) << 24) + \
+ ((png_uint_32)(*((buf) + 1)) << 16) + \
+ ((png_uint_32)(*((buf) + 2)) << 8) + \
+@@ -2584,27 +2755,550 @@
+ /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
+ * function) incorrectly returned a value of type png_uint_32.
+ */
+-# define png_get_uint_16(buf) \
++# define PNG_get_uint_16(buf) \
+ ((png_uint_16) \
+ (((unsigned int)(*(buf)) << 8) + \
+ ((unsigned int)(*((buf) + 1)))))
+
+-# define png_get_int_32(buf) \
++# define PNG_get_int_32(buf) \
+ ((png_int_32)((*(buf) & 0x80) \
+ ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \
+ : (png_int_32)png_get_uint_32(buf)))
++
++ /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h,
++ * but defining a macro name prefixed with PNG_PREFIX.
++ */
++# ifndef PNG_PREFIX
++# define png_get_uint_32(buf) PNG_get_uint_32(buf)
++# define png_get_uint_16(buf) PNG_get_uint_16(buf)
++# define png_get_int_32(buf) PNG_get_int_32(buf)
++# endif
++#else
++# ifdef PNG_PREFIX
++ /* No macros; revert to the (redefined) function */
++# define PNG_get_uint_32 (png_get_uint_32)
++# define PNG_get_uint_16 (png_get_uint_16)
++# define PNG_get_int_32 (png_get_int_32)
++# endif
+ #endif
+
+-/* Maintainer: Put new public prototypes here ^, in libpng.3, and project
+- * defs
++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) || \
++ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
++/*******************************************************************************
++ * SIMPLIFIED API
++ *******************************************************************************
++ *
++ * Please read the documentation in libpng-manual.txt (TODO: write said
++ * documentation) if you don't understand what follows.
++ *
++ * The simplified API hides the details of both libpng and the PNG file format
++ * itself. It allows PNG files to be read into a very limited number of
++ * in-memory bitmap formats or to be written from the same formats. If these
++ * formats do not accomodate your needs then you can, and should, use the more
++ * sophisticated APIs above - these support a wide variety of in-memory formats
++ * and a wide variety of sophisticated transformations to those formats as well
++ * as a wide variety of APIs to manipulate ancillary information.
++ *
++ * To read a PNG file using the simplified API:
++ *
++ * 1) Declare a 'png_image' structure (see below) on the stack and set the
++ * version field to PNG_IMAGE_VERSION.
++ * 2) Call the appropriate png_image_begin_read... function.
++ * 3) Set the png_image 'format' member to the required sample format.
++ * 4) Allocate a buffer for the image and, if required, the color-map.
++ * 5) Call png_image_finish_read to read the image and, if required, the
++ * color-map into your buffers.
++ *
++ * There are no restrictions on the format of the PNG input itself; all valid
++ * color types, bit depths, and interlace methods are acceptable, and the
++ * input image is transformed as necessary to the requested in-memory format
++ * during the png_image_finish_read() step. The only caveat is that if you
++ * request a color-mapped image from a PNG that is full-color or makes
++ * complex use of an alpha channel the transformation is extremely lossy and the
++ * result may look terrible.
++ *
++ * To write a PNG file using the simplified API:
++ *
++ * 1) Declare a 'png_image' structure on the stack and memset() it to all zero.
++ * 2) Initialize the members of the structure that describe the image, setting
++ * the 'format' member to the format of the image samples.
++ * 3) Call the appropriate png_image_write... function with a pointer to the
++ * image and, if necessary, the color-map to write the PNG data.
++ *
++ * png_image is a structure that describes the in-memory format of an image
++ * when it is being read or defines the in-memory format of an image that you
++ * need to write:
+ */
++#define PNG_IMAGE_VERSION 1
++
++typedef struct png_control *png_controlp;
++typedef struct
++{
++ png_controlp opaque; /* Initialize to NULL, free with png_image_free */
++ png_uint_32 version; /* Set to PNG_IMAGE_VERSION */
++ png_uint_32 width; /* Image width in pixels (columns) */
++ png_uint_32 height; /* Image height in pixels (rows) */
++ png_uint_32 format; /* Image format as defined below */
++ png_uint_32 flags; /* A bit mask containing informational flags */
++ png_uint_32 colormap_entries;
++ /* Number of entries in the color-map */
++
++ /* In the event of an error or warning the following 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
++ * are multiple warnings, only the first one is recorded.
++ *
++ * The upper 30 bits of this value are reserved, the low two bits contain
++ * a value as follows:
++ */
++# define PNG_IMAGE_WARNING 1
++# define PNG_IMAGE_ERROR 2
++ /*
++ * The result is a two-bit code such that a value more than 1 indicates
++ * a failure in the API just called:
++ *
++ * 0 - no warning or error
++ * 1 - warning
++ * 2 - error
++ * 3 - error preceded by warning
++ */
++# define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1)
++
++ png_uint_32 warning_or_error;
++
++ char message[64];
++} png_image, *png_imagep;
++
++/* The samples of the image have one to four channels whose components have
++ * original values in the range 0 to 1.0:
++ *
++ * 1: A single gray or luminance channel (G).
++ * 2: A gray/luminance channel and an alpha channel (GA).
++ * 3: Three red, green, blue color channels (RGB).
++ * 4: Three color channels and an alpha channel (RGBA).
++ *
++ * The components are encoded in one of two ways:
++ *
++ * a) As a small integer, value 0..255, contained in a single byte. For the
++ * alpha channel the original value is simply value/255. For the color or
++ * luminance channels the value is encoded according to the sRGB specification
++ * and matches the 8-bit format expected by typical display devices.
++ *
++ * The color/gray channels are not scaled (pre-multiplied) by the alpha
++ * channel and are suitable for passing to color management software.
++ *
++ * b) As a value in the range 0..65535, contained in a 2-byte integer. All
++ * channels can be converted to the original value by dividing by 65535; all
++ * channels are linear. Color channels use the RGB encoding (RGB end-points) of
++ * the sRGB specification. This encoding is identified by the
++ * PNG_FORMAT_FLAG_LINEAR flag below.
++ *
++ * When the simplified API needs to convert between sRGB and linear colorspaces,
++ * the actual sRGB transfer curve defined in the sRGB specification (see the
++ * article at http://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2
++ * approximation used elsewhere in libpng.
++ *
++ * When an alpha channel is present it is expected to denote pixel coverage
++ * of the color or luminance channels and is returned as an associated alpha
++ * channel: the color/gray channels are scaled (pre-multiplied) by the alpha
++ * value.
++ *
++ * The samples are either contained directly in the image data, between 1 and 8
++ * bytes per pixel according to the encoding, or are held in a color-map indexed
++ * by bytes in the image data. In the case of a color-map the color-map entries
++ * are individual samples, encoded as above, and the image data has one byte per
++ * pixel to select the relevant sample from the color-map.
++ */
++
++/* PNG_FORMAT_*
++ *
++ * #defines to be used in png_image::format. Each #define identifies a
++ * particular layout of sample data and, if present, alpha values. There are
++ * separate defines for each of the two component encodings.
++ *
++ * A format is built up using single bit flag values. All combinations are
++ * valid. Formats can be built up from the flag values or you can use one of
++ * the predefined values below. When testing formats always use the FORMAT_FLAG
++ * macros to test for individual features - future versions of the library may
++ * add new flags.
++ *
++ * When reading or writing color-mapped images the format should be set to the
++ * format of the entries in the color-map then png_image_{read,write}_colormap
++ * called to read or write the color-map and set the format correctly for the
++ * image data. Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly!
++ *
++ * NOTE: libpng can be built with particular features disabled, if you see
++ * compiler errors because the definition of one of the following flags has been
++ * compiled out it is because libpng does not have the required support. It is
++ * possible, however, for the libpng configuration to enable the format on just
++ * read or just write; in that case you may see an error at run time. You can
++ * guard against this by checking for the definition of the appropriate
++ * "_SUPPORTED" macro, one of:
++ *
++ * PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED
++ */
++#define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */
++#define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */
++#define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2 byte channels else 1 byte */
++#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */
++
++#ifdef PNG_FORMAT_BGR_SUPPORTED
++# define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */
++#endif
++
++#ifdef PNG_FORMAT_AFIRST_SUPPORTED
++# define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */
++#endif
++
++/* Commonly used formats have predefined macros.
++ *
++ * First the single byte (sRGB) formats:
++ */
++#define PNG_FORMAT_GRAY 0
++#define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA
++#define PNG_FORMAT_AG (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST)
++#define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR
++#define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR)
++#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA)
++#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST)
++#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA)
++#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST)
++
++/* Then the linear 2-byte formats. When naming these "Y" is used to
++ * indicate a luminance (gray) channel.
++ */
++#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR
++#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA)
++#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR)
++#define PNG_FORMAT_LINEAR_RGB_ALPHA \
++ (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA)
++
++/* With color-mapped formats the image data is one byte for each pixel, the byte
++ * is an index into the color-map which is formatted as above. To obtain a
++ * color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP
++ * to one of the above definitions, or you can use one of the definitions below.
++ */
++#define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP)
++#define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP)
++#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP)
++#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP)
++#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP)
++#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP)
++
++/* PNG_IMAGE macros
++ *
++ * These are convenience macros to derive information from a png_image
++ * structure. The PNG_IMAGE_SAMPLE_ macros return values appropriate to the
++ * actual image sample values - either the entries in the color-map or the
++ * pixels in the image. The PNG_IMAGE_PIXEL_ macros return corresponding values
++ * for the pixels and will always return 1 for color-mapped formats. The
++ * remaining macros return information about the rows in the image and the
++ * complete image.
++ *
++ * NOTE: All the macros that take a png_image::format parameter are compile time
++ * constants if the format parameter is, itself, a constant. Therefore these
++ * macros can be used in array declarations and case labels where required.
++ * Similarly the macros are also pre-processor constants (sizeof is not used) so
++ * they can be used in #if tests.
++ *
++ * First the information about the samples.
++ */
++#define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\
++ (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1)
++ /* Return the total number of channels in a given format: 1..4 */
++
++#define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\
++ ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1)
++ /* Return the size in bytes of a single component of a pixel or color-map
++ * entry (as appropriate) in the image: 1 or 2.
++ */
++
++#define PNG_IMAGE_SAMPLE_SIZE(fmt)\
++ (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt))
++ /* This is the size of the sample data for one sample. If the image is
++ * color-mapped it is the size of one color-map entry (and image pixels are
++ * one byte in size), otherwise it is the size of one image pixel.
++ */
++
++#define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\
++ (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256)
++ /* The maximum size of the color-map required by the format expressed in a
++ * count of components. This can be used to compile-time allocate a
++ * color-map:
++ *
++ * png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)];
++ *
++ * png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)];
++ *
++ * Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the
++ * information from one of the png_image_begin_read_ APIs and dynamically
++ * allocate the required memory.
++ */
++
++/* Corresponding information about the pixels */
++#define PNG_IMAGE_PIXEL_(test,fmt)\
++ (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt))
++
++#define PNG_IMAGE_PIXEL_CHANNELS(fmt)\
++ PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt)
++ /* The number of separate channels (components) in a pixel; 1 for a
++ * color-mapped image.
++ */
++
++#define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\
++ PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt)
++ /* The size, in bytes, of each component in a pixel; 1 for a color-mapped
++ * image.
++ */
++
++#define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt)
++ /* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */
++
++/* Information about the whole row, or whole image */
++#define PNG_IMAGE_ROW_STRIDE(image)\
++ (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width)
++ /* Return the total number of components in a single row of the image; this
++ * is the minimum 'row stride', the minimum count of components between each
++ * row. For a color-mapped image this is the minimum number of bytes in a
++ * row.
++ */
++
++#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\
++ (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride))
++ /* Return the size, in bytes, of an image buffer given a png_image and a row
++ * stride - the number of components to leave space for in each row.
++ */
++
++#define PNG_IMAGE_SIZE(image)\
++ PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image))
++ /* Return the size, in bytes, of the image in memory given just a png_image;
++ * the row stride is the minimum stride required for the image.
++ */
++
++#define PNG_IMAGE_COLORMAP_SIZE(image)\
++ (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries)
++ /* Return the size, in bytes, of the color-map of this image. If the image
++ * format is not a color-map format this will return a size sufficient for
++ * 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if
++ * you don't want to allocate a color-map in this case.
++ */
++
++/* PNG_IMAGE_FLAG_*
++ *
++ * Flags containing additional information about the image are held in the
++ * 'flags' field of png_image.
++ */
++#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01
++ /* This indicates the the RGB values of the in-memory bitmap do not
++ * correspond to the red, green and blue end-points defined by sRGB.
++ */
++
++#define PNG_IMAGE_FLAG_FAST 0x02
++ /* On write emphasise speed over compression; the resultant PNG file will be
++ * larger but will be produced significantly faster, particular for large
++ * images. Do not use this option for images which will be distributed, only
++ * used it when producing intermediate files that will be read back in
++ * repeatedly. For a typical 24-bit image the option will double the read
++ * speed at the cost of increasing the image size by 25%, however for many
++ * more compressible images the PNG file can be 10 times larger with only a
++ * slight speed gain.
++ */
++
++#define PNG_IMAGE_FLAG_16BIT_sRGB 0x04
++ /* On read if the image is a 16-bit per component image and there is no gAMA
++ * or sRGB chunk assume that the components are sRGB encoded. Notice that
++ * images output by the simplified API always have gamma information; setting
++ * this flag only affects the interpretation of 16-bit images from an
++ * external source. It is recommended that the application expose this flag
++ * to the user; the user can normally easily recognize the difference between
++ * linear and sRGB encoding. This flag has no effect on write - the data
++ * passed to the write APIs must have the correct encoding (as defined
++ * above.)
++ *
++ * If the flag is not set (the default) input 16-bit per component data is
++ * assumed to be linear.
++ *
++ * NOTE: the flag can only be set after the png_image_begin_read_ call,
++ * because that call initializes the 'flags' field.
++ */
++
++#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
++/* READ APIs
++ * ---------
++ *
++ * The png_image passed to the read APIs must have been initialized by setting
++ * the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.)
++ */
++#ifdef PNG_STDIO_SUPPORTED
++PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image,
++ const char *file_name));
++ /* The named file is opened for read and the image header is filled in
++ * from the PNG header in the file.
++ */
++
++PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image,
++ FILE* file));
++ /* The PNG header is read from the stdio FILE object. */
++#endif /* STDIO */
++
++PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
++ png_const_voidp memory, png_size_t size));
++ /* The PNG header is read from the given memory buffer. */
++
++PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image,
++ png_const_colorp background, void *buffer, png_int_32 row_stride,
++ void *colormap));
++ /* Finish reading the image into the supplied buffer and clean up the
++ * png_image structure.
++ *
++ * row_stride is the step, in byte or 2-byte units as appropriate,
++ * between adjacent rows. A positive stride indicates that the top-most row
++ * is first in the buffer - the normal top-down arrangement. A negative
++ * stride indicates that the bottom-most row is first in the buffer.
++ *
++ * background need only be supplied if an alpha channel must be removed from
++ * a png_byte format and the removal is to be done by compositing on a solid
++ * color; otherwise it may be NULL and any composition will be done directly
++ * onto the buffer. The value is an sRGB color to use for the background,
++ * for grayscale output the green channel is used.
++ *
++ * background must be supplied when an alpha channel must be removed from a
++ * single byte color-mapped output format, in other words if:
++ *
++ * 1) The original format from png_image_begin_read_from_* had
++ * PNG_FORMAT_FLAG_ALPHA set.
++ * 2) The format set by the application does not.
++ * 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and
++ * PNG_FORMAT_FLAG_LINEAR *not* set.
++ *
++ * For linear output removing the alpha channel is always done by compositing
++ * on black and background is ignored.
++ *
++ * colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must
++ * be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE.
++ * image->colormap_entries will be updated to the actual number of entries
++ * written to the colormap; this may be less than the original value.
++ */
++
++PNG_EXPORT(238, void, png_image_free, (png_imagep image));
++ /* Free any data allocated by libpng in image->opaque, setting the pointer to
++ * NULL. May be called at any time after the structure is initialized.
++ */
++#endif /* SIMPLIFIED_READ */
++
++#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
++#ifdef PNG_STDIO_SUPPORTED
++/* WRITE APIS
++ * ----------
++ * For write you must initialize a png_image structure to describe the image to
++ * be written. To do this use memset to set the whole structure to 0 then
++ * initialize fields describing your image.
++ *
++ * version: must be set to PNG_IMAGE_VERSION
++ * opaque: must be initialized to NULL
++ * width: image width in pixels
++ * height: image height in rows
++ * format: the format of the data (image and color-map) you wish to write
++ * flags: set to 0 unless one of the defined flags applies; set
++ * PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB
++ * values do not correspond to the colors in sRGB.
++ * colormap_entries: set to the number of entries in the color-map (0 to 256)
++ */
++PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image,
++ const char *file, int convert_to_8bit, const void *buffer,
++ png_int_32 row_stride, const void *colormap));
++ /* Write the image to the named file. */
++
++PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
++ int convert_to_8_bit, const void *buffer, png_int_32 row_stride,
++ const void *colormap));
++ /* Write the image to the given (FILE*). */
++
++/* With both write APIs if image is in one of the linear formats with 16-bit
++ * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
++ * gamma encoded according to the sRGB specification, otherwise a 16-bit linear
++ * encoded PNG file is written.
++ *
++ * With color-mapped data formats the colormap parameter point to a color-map
++ * with at least image->colormap_entries encoded in the specified format. If
++ * the format is linear the written PNG color-map will be converted to sRGB
++ * regardless of the convert_to_8_bit flag.
++ *
++ * With all APIs row_stride is handled as in the read APIs - it is the spacing
++ * from one row to the next in component sized units (1 or 2 bytes) and if
++ * negative indicates a bottom-up row layout in the buffer.
++ *
++ * Note that the write API does not support interlacing or sub-8-bit pixels.
++ */
++#endif /* STDIO */
++#endif /* SIMPLIFIED_WRITE */
++/*******************************************************************************
++ * END OF SIMPLIFIED API
++ ******************************************************************************/
++#endif /* SIMPLIFIED_{READ|WRITE} */
++
++#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
++PNG_EXPORT(242, void, png_set_check_for_invalid_index,
++ (png_structrp png_ptr, int allowed));
++# ifdef PNG_GET_PALETTE_MAX_SUPPORTED
++PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
++ png_const_infop info_ptr));
++# endif
++#endif /* CHECK_FOR_INVALID_INDEX */
++
++/*******************************************************************************
++ * IMPLEMENTATION OPTIONS
++ *******************************************************************************
++ *
++ * Support for arbitrary implementation-specific optimizations. The API allows
++ * particular options to be turned on or off. 'Option' is the number of the
++ * option and 'onoff' is 0 (off) or non-0 (on). The value returned is given
++ * by the PNG_OPTION_ defines below.
++ *
++ * HARDWARE: normally hardware capabilites, such as the Intel SSE instructions,
++ * are detected at run time, however sometimes it may be impossible
++ * to do this in user mode, in which case it is necessary to discover
++ * the capabilities in an OS specific way. Such capabilities are
++ * listed here when libpng has support for them and must be turned
++ * ON by the application if present.
++ *
++ * SOFTWARE: sometimes software optimizations actually result in performance
++ * decrease on some architectures or systems, or with some sets of
++ * PNG images. 'Software' options allow such optimizations to be
++ * selected at run time.
++ */
++#ifdef PNG_SET_OPTION_SUPPORTED
++#ifdef PNG_ARM_NEON_API_SUPPORTED
++# define PNG_ARM_NEON 0 /* HARDWARE: ARM Neon SIMD instructions supported */
++#endif
++#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */
++#define PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */
++#define PNG_OPTION_NEXT 6 /* Next option - numbers must be even */
++
++/* Return values: NOTE: there are four values and 'off' is *not* zero */
++#define PNG_OPTION_UNSET 0 /* Unset - defaults to off */
++#define PNG_OPTION_INVALID 1 /* Option number out of range */
++#define PNG_OPTION_OFF 2
++#define PNG_OPTION_ON 3
++
++PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
++ int onoff));
++#endif /* SET_OPTION */
++
++/*******************************************************************************
++ * END OF HARDWARE AND SOFTWARE OPTIONS
++ ******************************************************************************/
++
++/* Maintainer: Put new public prototypes here ^, in libpng.3, in project
++ * defs, and in scripts/symbols.def.
++ */
+
+ /* The last ordinal number (this is the *last* one already used; the next
+- * one to use is one more than this.) Maintainer, remember to add an entry to
+- * scripts/symbols.def as well.
++ * one to use is one more than this.)
+ */
+ #ifdef PNG_EXPORT_LAST_ORDINAL
+- PNG_EXPORT_LAST_ORDINAL(229);
++ PNG_EXPORT_LAST_ORDINAL(244);
+ #endif
+
+ #ifdef __cplusplus
+--- ./jdk/src/share/native/sun/awt/libpng/pngconf.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngconf.h Thu Feb 05 13:00:26 2015 +0100
+@@ -29,9 +29,9 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * libpng version 1.5.4 - July 7, 2011
++ * libpng version 1.6.16,December 22, 2014
+ *
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -50,37 +50,73 @@
+ #ifndef PNGCONF_H
+ #define PNGCONF_H
+
+-#ifndef PNG_BUILDING_SYMBOL_TABLE
+-/* PNG_NO_LIMITS_H may be used to turn off the use of the standard C
+- * definition file for machine specific limits, this may impact the
+- * correctness of the definitons below (see uses of INT_MAX).
+- */
+-# ifndef PNG_NO_LIMITS_H
+-# include <limits.h>
++/* To do: Do all of this in scripts/pnglibconf.dfa */
++#ifdef PNG_SAFE_LIMITS_SUPPORTED
++# ifdef PNG_USER_WIDTH_MAX
++# undef PNG_USER_WIDTH_MAX
++# define PNG_USER_WIDTH_MAX 1000000L
+ # endif
+-
+-/* For the memory copy APIs (i.e. the standard definitions of these),
+- * because this file defines png_memcpy and so on the base APIs must
+- * be defined here.
+- */
+-# ifdef BSD
+-# include <strings.h>
+-# else
+-# include <string.h>
++# ifdef PNG_USER_HEIGHT_MAX
++# undef PNG_USER_HEIGHT_MAX
++# define PNG_USER_HEIGHT_MAX 1000000L
+ # endif
+-
+-/* For png_FILE_p - this provides the standard definition of a
+- * FILE
+- */
+-# ifdef PNG_STDIO_SUPPORTED
+-# include <stdio.h>
++# ifdef PNG_USER_CHUNK_MALLOC_MAX
++# undef PNG_USER_CHUNK_MALLOC_MAX
++# define PNG_USER_CHUNK_MALLOC_MAX 4000000L
++# endif
++# ifdef PNG_USER_CHUNK_CACHE_MAX
++# undef PNG_USER_CHUNK_CACHE_MAX
++# define PNG_USER_CHUNK_CACHE_MAX 128
+ # endif
+ #endif
+
++#ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */
++
++/* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C
++ * compiler for correct compilation. The following header files are required by
++ * the standard. If your compiler doesn't provide these header files, or they
++ * do not match the standard, you will need to provide/improve them.
++ */
++#include <limits.h>
++#include <stddef.h>
++
++/* Library header files. These header files are all defined by ISOC90; libpng
++ * expects conformant implementations, however, an ISOC90 conformant system need
++ * not provide these header files if the functionality cannot be implemented.
++ * In this case it will be necessary to disable the relevant parts of libpng in
++ * the build of pnglibconf.h.
++ *
++ * Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not
++ * include this unnecessary header file.
++ */
++
++#ifdef PNG_STDIO_SUPPORTED
++ /* Required for the definition of FILE: */
++# include <stdio.h>
++#endif
++
++#ifdef PNG_SETJMP_SUPPORTED
++ /* Required for the definition of jmp_buf and the declaration of longjmp: */
++# include <setjmp.h>
++#endif
++
++#ifdef PNG_CONVERT_tIME_SUPPORTED
++ /* Required for struct tm: */
++# include <time.h>
++#endif
++
++#endif /* PNG_BUILDING_SYMBOL_TABLE */
++
++/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using
++ * PNG_NO_CONST; this is no longer supported except for data declarations which
++ * apparently still cause problems in 2011 on some compilers.
++ */
++#define PNG_CONST const /* backward compatibility only */
++
+ /* This controls optimization of the reading of 16 and 32 bit values
+ * from PNG files. It can be set on a per-app-file basis - it
+- * just changes whether a macro is used to the function is called.
+- * The library builder sets the default, if read functions are not
++ * just changes whether a macro is used when the function is called.
++ * The library builder sets the default; if read functions are not
+ * built into the library the macro implementation is forced on.
+ */
+ #ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED
+@@ -100,28 +136,13 @@
+ * may be changed on a per-file basis when compiling against libpng.
+ */
+
+-/* The PNGARG macro protects us against machines that don't have function
+- * prototypes (ie K&R style headers). If your compiler does not handle
+- * function prototypes, define this macro and use the included ansi2knr.
+- * I've always been able to use _NO_PROTO as the indicator, but you may
+- * need to drag the empty declaration out in front of here, or change the
+- * ifdef to suit your own needs.
++/* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect
++ * against legacy (pre ISOC90) compilers that did not understand function
++ * prototypes. It is not required for modern C compilers.
+ */
+ #ifndef PNGARG
+-
+-# ifdef OF /* zlib prototype munger */
+-# define PNGARG(arglist) OF(arglist)
+-# else
+-
+-# ifdef _NO_PROTO
+-# define PNGARG(arglist) ()
+-# else
+-# define PNGARG(arglist) arglist
+-# endif /* _NO_PROTO */
+-
+-# endif /* OF */
+-
+-#endif /* PNGARG */
++# define PNGARG(arglist) arglist
++#endif
+
+ /* Function calling conventions.
+ * =============================
+@@ -192,7 +213,9 @@
+ * 'type', compiler specific.
+ *
+ * PNG_DLL_EXPORT Set to the magic to use during a libpng build to
+- * make a symbol exported from the DLL.
++ * make a symbol exported from the DLL. Not used in the
++ * public header files; see pngpriv.h for how it is used
++ * in the libpng build.
+ *
+ * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come
+ * from a DLL - used to define PNG_IMPEXP when
+@@ -203,18 +226,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
+@@ -225,9 +246,12 @@
+ # define PNGCAPI __watcall
+ # endif
+
+-# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800))
++# 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
+@@ -242,10 +266,11 @@
+ # define PNGAPI _stdcall
+ # endif
+ # endif /* compiler/api */
++
+ /* NOTE: PNGCBAPI always defaults to PNGCAPI. */
+
+ # if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD)
+- ERROR: PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed
++# error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed"
+ # endif
+
+ # if (defined(_MSC_VER) && _MSC_VER < 800) ||\
+@@ -265,7 +290,7 @@
+ # endif
+ # endif /* compiler */
+
+-#else /* !Windows/x86 */
++#else /* !Windows */
+ # if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
+ # define PNGAPI _System
+ # else /* !Windows/x86 && !OS/2 */
+@@ -286,25 +311,14 @@
+ # define PNGAPI PNGCAPI
+ #endif
+
+-/* The default for PNG_IMPEXP depends on whether the library is
+- * being built or used.
++/* PNG_IMPEXP may be set on the compilation system command line or (if not set)
++ * then in an internal header file when building the library, otherwise (when
++ * using the library) it is set here.
+ */
+ #ifndef PNG_IMPEXP
+-# ifdef PNGLIB_BUILD
+- /* Building the library */
+-# if (defined(DLL_EXPORT)/*from libtool*/ ||\
+- defined(_WINDLL) || defined(_DLL) || defined(__DLL__) ||\
+- defined(_USRDLL) ||\
+- defined(PNG_BUILD_DLL)) && defined(PNG_DLL_EXPORT)
+- /* Building a DLL. */
+-# define PNG_IMPEXP PNG_DLL_EXPORT
+-# endif /* DLL */
+-# else
+- /* Using the library */
+-# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT)
+- /* This forces use of a DLL, disallowing static linking */
+-# define PNG_IMPEXP PNG_DLL_IMPORT
+-# endif
++# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT)
++ /* This forces use of a DLL, disallowing static linking */
++# define PNG_IMPEXP PNG_DLL_IMPORT
+ # endif
+
+ # ifndef PNG_IMPEXP
+@@ -370,26 +384,48 @@
+
+ #ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED
+ /* Support for compiler specific function attributes. These are used
+- * so that where compiler support is available incorrect use of API
++ * so that where compiler support is available, incorrect use of API
+ * functions in png.h will generate compiler warnings. Added at libpng
+- * version 1.2.41.
++ * version 1.2.41. Disabling these removes the warnings but may also produce
++ * less efficient code.
+ */
+-# if defined(__GNUC__)
++# if defined(__clang__) && defined(__has_attribute)
++ /* Clang defines both __clang__ and __GNUC__. Check __clang__ first. */
++# if !defined(PNG_USE_RESULT) && __has_attribute(__warn_unused_result__)
++# define PNG_USE_RESULT __attribute__((__warn_unused_result__))
++# endif
++# if !defined(PNG_NORETURN) && __has_attribute(__noreturn__)
++# define PNG_NORETURN __attribute__((__noreturn__))
++# endif
++# if !defined(PNG_ALLOCATED) && __has_attribute(__malloc__)
++# define PNG_ALLOCATED __attribute__((__malloc__))
++# endif
++# if !defined(PNG_DEPRECATED) && __has_attribute(__deprecated__)
++# define PNG_DEPRECATED __attribute__((__deprecated__))
++# endif
++# if !defined(PNG_PRIVATE)
++# ifdef __has_extension
++# if __has_extension(attribute_unavailable_with_message)
++# define PNG_PRIVATE __attribute__((__unavailable__(\
++ "This function is not exported by libpng.")))
++# endif
++# endif
++# endif
++# ifndef PNG_RESTRICT
++# define PNG_RESTRICT __restrict
++# endif
++
++# elif defined(__GNUC__)
+ # ifndef PNG_USE_RESULT
+ # define PNG_USE_RESULT __attribute__((__warn_unused_result__))
+ # endif
+ # ifndef PNG_NORETURN
+ # define PNG_NORETURN __attribute__((__noreturn__))
+ # endif
+-# ifndef PNG_ALLOCATED
+-# define PNG_ALLOCATED __attribute__((__malloc__))
+-# endif
+-
+- /* This specifically protects structure members that should only be
+- * accessed from within the library, therefore should be empty during
+- * a library build.
+- */
+-# ifndef PNGLIB_BUILD
++# if __GNUC__ >= 3
++# ifndef PNG_ALLOCATED
++# define PNG_ALLOCATED __attribute__((__malloc__))
++# endif
+ # ifndef PNG_DEPRECATED
+ # define PNG_DEPRECATED __attribute__((__deprecated__))
+ # endif
+@@ -402,10 +438,14 @@
+ __attribute__((__deprecated__))
+ # endif
+ # endif
+-# endif /* PNGLIB_BUILD */
+-# endif /* __GNUC__ */
++# if ((__GNUC__ > 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1))
++# ifndef PNG_RESTRICT
++# define PNG_RESTRICT __restrict
++# endif
++# endif /* __GNUC__.__GNUC_MINOR__ > 3.0 */
++# endif /* __GNUC__ >= 3 */
+
+-# if defined(_MSC_VER) && (_MSC_VER >= 1300)
++# elif defined(_MSC_VER) && (_MSC_VER >= 1300)
+ # ifndef PNG_USE_RESULT
+ # define PNG_USE_RESULT /* not supported */
+ # endif
+@@ -417,20 +457,23 @@
+ # define PNG_ALLOCATED __declspec(restrict)
+ # endif
+ # endif
++# ifndef PNG_DEPRECATED
++# define PNG_DEPRECATED __declspec(deprecated)
++# endif
++# ifndef PNG_PRIVATE
++# define PNG_PRIVATE __declspec(deprecated)
++# endif
++# ifndef PNG_RESTRICT
++# if (_MSC_VER >= 1400)
++# define PNG_RESTRICT __restrict
++# endif
++# endif
+
+- /* This specifically protects structure members that should only be
+- * accessed from within the library, therefore should be empty during
+- * a library build.
+- */
+-# ifndef PNGLIB_BUILD
+-# ifndef PNG_DEPRECATED
+-# define PNG_DEPRECATED __declspec(deprecated)
+-# endif
+-# ifndef PNG_PRIVATE
+-# define PNG_PRIVATE __declspec(deprecated)
+-# endif
+-# endif /* PNGLIB_BUILD */
+-# endif /* _MSC_VER */
++# elif defined(__WATCOMC__)
++# ifndef PNG_RESTRICT
++# define PNG_RESTRICT __restrict
++# endif
++# endif
+ #endif /* PNG_PEDANTIC_WARNINGS */
+
+ #ifndef PNG_DEPRECATED
+@@ -448,10 +491,14 @@
+ #ifndef PNG_PRIVATE
+ # define PNG_PRIVATE /* This is a private libpng function */
+ #endif
++#ifndef PNG_RESTRICT
++# define PNG_RESTRICT /* The C99 "restrict" feature */
++#endif
++
+ #ifndef PNG_FP_EXPORT /* A floating point API. */
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ # define PNG_FP_EXPORT(ordinal, type, name, args)\
+- PNG_EXPORT(ordinal, type, name, args)
++ PNG_EXPORT(ordinal, type, name, args);
+ # else /* No floating point APIs */
+ # define PNG_FP_EXPORT(ordinal, type, name, args)
+ # endif
+@@ -459,189 +506,167 @@
+ #ifndef PNG_FIXED_EXPORT /* A fixed point API. */
+ # ifdef PNG_FIXED_POINT_SUPPORTED
+ # define PNG_FIXED_EXPORT(ordinal, type, name, args)\
+- PNG_EXPORT(ordinal, type, name, args)
++ PNG_EXPORT(ordinal, type, name, args);
+ # else /* No fixed point APIs */
+ # define PNG_FIXED_EXPORT(ordinal, type, name, args)
+ # endif
+ #endif
+
+-/* The following uses const char * instead of char * for error
+- * and warning message functions, so some compilers won't complain.
+- * If you do not want to use const, define PNG_NO_CONST here.
++#ifndef PNG_BUILDING_SYMBOL_TABLE
++/* Some typedefs to get us started. These should be safe on most of the common
++ * platforms.
+ *
+- * This should not change how the APIs are called, so it can be done
+- * on a per-file basis in the application.
++ * png_uint_32 and png_int_32 may, currently, be larger than required to hold a
++ * 32-bit value however this is not normally advisable.
++ *
++ * png_uint_16 and png_int_16 should always be two bytes in size - this is
++ * verified at library build time.
++ *
++ * png_byte must always be one byte in size.
++ *
++ * The checks below use constants from limits.h, as defined by the ISOC90
++ * standard.
+ */
+-#ifndef PNG_CONST
+-# ifndef PNG_NO_CONST
+-# define PNG_CONST const
+-# else
+-# define PNG_CONST
++#if CHAR_BIT == 8 && UCHAR_MAX == 255
++ typedef unsigned char png_byte;
++#else
++# error "libpng requires 8 bit bytes"
++#endif
++
++#if INT_MIN == -32768 && INT_MAX == 32767
++ typedef int png_int_16;
++#elif SHRT_MIN == -32768 && SHRT_MAX == 32767
++ typedef short png_int_16;
++#else
++# error "libpng requires a signed 16 bit type"
++#endif
++
++#if UINT_MAX == 65535
++ typedef unsigned int png_uint_16;
++#elif USHRT_MAX == 65535
++ typedef unsigned short png_uint_16;
++#else
++# error "libpng requires an unsigned 16 bit type"
++#endif
++
++#if INT_MIN < -2147483646 && INT_MAX > 2147483646
++ typedef int png_int_32;
++#elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646
++ typedef long int png_int_32;
++#else
++# error "libpng requires a signed 32 bit (or more) type"
++#endif
++
++#if UINT_MAX > 4294967294
++ typedef unsigned int png_uint_32;
++#elif ULONG_MAX > 4294967294
++ typedef unsigned long int png_uint_32;
++#else
++# error "libpng requires an unsigned 32 bit (or more) type"
++#endif
++
++/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however,
++ * requires an ISOC90 compiler and relies on consistent behavior of sizeof.
++ */
++typedef size_t png_size_t;
++typedef ptrdiff_t png_ptrdiff_t;
++
++/* libpng needs to know the maximum value of 'size_t' and this controls the
++ * definition of png_alloc_size_t, below. This maximum value of size_t limits
++ * but does not control the maximum allocations the library makes - there is
++ * direct application control of this through png_set_user_limits().
++ */
++#ifndef PNG_SMALL_SIZE_T
++ /* Compiler specific tests for systems where size_t is known to be less than
++ * 32 bits (some of these systems may no longer work because of the lack of
++ * 'far' support; see above.)
++ */
++# if (defined(__TURBOC__) && !defined(__FLAT__)) ||\
++ (defined(_MSC_VER) && defined(MAXSEG_64K))
++# define PNG_SMALL_SIZE_T
+ # endif
+ #endif
+
+-/* Some typedefs to get us started. These should be safe on most of the
+- * common platforms. The typedefs should be at least as large as the
+- * numbers suggest (a png_uint_32 must be at least 32 bits long), but they
+- * don't have to be exactly that size. Some compilers dislike passing
+- * unsigned shorts as function parameters, so you may be better off using
+- * unsigned int for png_uint_16.
++/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no
++ * smaller than png_uint_32. Casts from png_size_t or png_uint_32 to
++ * png_alloc_size_t are not necessary; in fact, it is recommended not to use
++ * them at all so that the compiler can complain when something turns out to be
++ * problematic.
++ *
++ * Casts in the other direction (from png_alloc_size_t to png_size_t or
++ * png_uint_32) should be explicitly applied; however, we do not expect to
++ * encounter practical situations that require such conversions.
++ *
++ * PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than
++ * 4294967295 - i.e. less than the maximum value of png_uint_32.
++ */
++#ifdef PNG_SMALL_SIZE_T
++ typedef png_uint_32 png_alloc_size_t;
++#else
++ typedef png_size_t png_alloc_size_t;
++#endif
++
++/* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler
++ * implementations of Intel CPU specific support of user-mode segmented address
++ * spaces, where 16-bit pointers address more than 65536 bytes of memory using
++ * separate 'segment' registers. The implementation requires two different
++ * types of pointer (only one of which includes the segment value.)
++ *
++ * If required this support is available in version 1.2 of libpng and may be
++ * available in versions through 1.5, although the correctness of the code has
++ * not been verified recently.
+ */
+
+-#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL)
+-typedef unsigned int png_uint_32;
+-typedef int png_int_32;
+-#else
+-typedef unsigned long png_uint_32;
+-typedef long png_int_32;
+-#endif
+-typedef unsigned short png_uint_16;
+-typedef short png_int_16;
+-typedef unsigned char png_byte;
+-
+-#ifdef PNG_NO_SIZE_T
+-typedef unsigned int png_size_t;
+-#else
+-typedef size_t png_size_t;
+-#endif
+-#define png_sizeof(x) (sizeof (x))
+-
+-/* The following is needed for medium model support. It cannot be in the
+- * pngpriv.h header. Needs modification for other compilers besides
+- * MSC. Model independent support declares all arrays and pointers to be
+- * large using the far keyword. The zlib version used must also support
+- * model independent data. As of version zlib 1.0.4, the necessary changes
+- * have been made in zlib. The USE_FAR_KEYWORD define triggers other
+- * changes that are needed. (Tim Wegner)
+- */
+-
+-/* Separate compiler dependencies (problem here is that zlib.h always
+- * defines FAR. (SJT)
+- */
+-#ifdef __BORLANDC__
+-# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)
+-# define LDATA 1
+-# else
+-# define LDATA 0
+-# endif
+- /* GRR: why is Cygwin in here? Cygwin is not Borland C... */
+-# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)
+-# define PNG_MAX_MALLOC_64K /* only used in build */
+-# if (LDATA != 1)
+-# ifndef FAR
+-# define FAR __far
+-# endif
+-# define USE_FAR_KEYWORD
+-# endif /* LDATA != 1 */
+- /* Possibly useful for moving data out of default segment.
+- * Uncomment it if you want. Could also define FARDATA as
+- * const if your compiler supports it. (SJT)
+-# define FARDATA FAR
+- */
+-# endif /* __WIN32__, __FLAT__, __CYGWIN__ */
+-#endif /* __BORLANDC__ */
+-
+-
+-/* Suggest testing for specific compiler first before testing for
+- * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM,
+- * making reliance oncertain keywords suspect. (SJT)
+- */
+-
+-/* MSC Medium model */
+-#ifdef FAR
+-# ifdef M_I86MM
+-# define USE_FAR_KEYWORD
+-# define FARDATA FAR
+-# include <dos.h>
+-# endif
+-#endif
+-
+-/* SJT: default case */
+-#ifndef FAR
+-# define FAR
+-#endif
+-
+-/* At this point FAR is always defined */
+-#ifndef FARDATA
+-# define FARDATA
+-#endif
+-
+-/* Typedef for floating-point numbers that are converted
+- * to fixed-point with a multiple of 100,000, e.g., gamma
++/* Typedef for floating-point numbers that are converted to fixed-point with a
++ * multiple of 100,000, e.g., gamma
+ */
+ typedef png_int_32 png_fixed_point;
+
+ /* Add typedefs for pointers */
+-typedef void FAR * png_voidp;
+-typedef PNG_CONST void FAR * png_const_voidp;
+-typedef png_byte FAR * png_bytep;
+-typedef PNG_CONST png_byte FAR * png_const_bytep;
+-typedef png_uint_32 FAR * png_uint_32p;
+-typedef PNG_CONST png_uint_32 FAR * png_const_uint_32p;
+-typedef png_int_32 FAR * png_int_32p;
+-typedef PNG_CONST png_int_32 FAR * png_const_int_32p;
+-typedef png_uint_16 FAR * png_uint_16p;
+-typedef PNG_CONST png_uint_16 FAR * png_const_uint_16p;
+-typedef png_int_16 FAR * png_int_16p;
+-typedef PNG_CONST png_int_16 FAR * png_const_int_16p;
+-typedef char FAR * png_charp;
+-typedef PNG_CONST char FAR * png_const_charp;
+-typedef png_fixed_point FAR * png_fixed_point_p;
+-typedef PNG_CONST png_fixed_point FAR * png_const_fixed_point_p;
+-typedef png_size_t FAR * png_size_tp;
+-typedef PNG_CONST png_size_t FAR * png_const_size_tp;
++typedef void * png_voidp;
++typedef const void * png_const_voidp;
++typedef png_byte * png_bytep;
++typedef const png_byte * png_const_bytep;
++typedef png_uint_32 * png_uint_32p;
++typedef const png_uint_32 * png_const_uint_32p;
++typedef png_int_32 * png_int_32p;
++typedef const png_int_32 * png_const_int_32p;
++typedef png_uint_16 * png_uint_16p;
++typedef const png_uint_16 * png_const_uint_16p;
++typedef png_int_16 * png_int_16p;
++typedef const png_int_16 * png_const_int_16p;
++typedef char * png_charp;
++typedef const char * png_const_charp;
++typedef png_fixed_point * png_fixed_point_p;
++typedef const png_fixed_point * png_const_fixed_point_p;
++typedef png_size_t * png_size_tp;
++typedef const png_size_t * png_const_size_tp;
+
+ #ifdef PNG_STDIO_SUPPORTED
+ typedef FILE * png_FILE_p;
+ #endif
+
+ #ifdef PNG_FLOATING_POINT_SUPPORTED
+-typedef double FAR * png_doublep;
+-typedef PNG_CONST double FAR * png_const_doublep;
++typedef double * png_doublep;
++typedef const double * png_const_doublep;
+ #endif
+
+ /* Pointers to pointers; i.e. arrays */
+-typedef png_byte FAR * FAR * png_bytepp;
+-typedef png_uint_32 FAR * FAR * png_uint_32pp;
+-typedef png_int_32 FAR * FAR * png_int_32pp;
+-typedef png_uint_16 FAR * FAR * png_uint_16pp;
+-typedef png_int_16 FAR * FAR * png_int_16pp;
+-typedef PNG_CONST char FAR * FAR * png_const_charpp;
+-typedef char FAR * FAR * png_charpp;
+-typedef png_fixed_point FAR * FAR * png_fixed_point_pp;
++typedef png_byte * * png_bytepp;
++typedef png_uint_32 * * png_uint_32pp;
++typedef png_int_32 * * png_int_32pp;
++typedef png_uint_16 * * png_uint_16pp;
++typedef png_int_16 * * png_int_16pp;
++typedef const char * * png_const_charpp;
++typedef char * * png_charpp;
++typedef png_fixed_point * * png_fixed_point_pp;
+ #ifdef PNG_FLOATING_POINT_SUPPORTED
+-typedef double FAR * FAR * png_doublepp;
++typedef double * * png_doublepp;
+ #endif
+
+ /* Pointers to pointers to pointers; i.e., pointer to array */
+-typedef char FAR * FAR * FAR * png_charppp;
++typedef char * * * png_charppp;
+
+-/* png_alloc_size_t is guaranteed to be no smaller than png_size_t,
+- * and no smaller than png_uint_32. Casts from png_size_t or png_uint_32
+- * to png_alloc_size_t are not necessary; in fact, it is recommended
+- * not to use them at all so that the compiler can complain when something
+- * turns out to be problematic.
+- * Casts in the other direction (from png_alloc_size_t to png_size_t or
+- * png_uint_32) should be explicitly applied; however, we do not expect
+- * to encounter practical situations that require such conversions.
+- */
+-#if defined(__TURBOC__) && !defined(__FLAT__)
+- typedef unsigned long png_alloc_size_t;
+-#else
+-# if defined(_MSC_VER) && defined(MAXSEG_64K)
+- typedef unsigned long png_alloc_size_t;
+-# else
+- /* This is an attempt to detect an old Windows system where (int) is
+- * actually 16 bits, in that case png_malloc must have an argument with a
+- * bigger size to accommodate the requirements of the library.
+- */
+-# if (defined(_Windows) || defined(_WINDOWS) || defined(_WINDOWS_)) && \
+- (!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL)
+- typedef DWORD png_alloc_size_t;
+-# else
+- typedef png_size_t png_alloc_size_t;
+-# endif
+-# endif
+-#endif
++#endif /* PNG_BUILDING_SYMBOL_TABLE */
+
+ #endif /* PNGCONF_H */
+--- ./jdk/src/share/native/sun/awt/libpng/pngdebug.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngdebug.h Thu Feb 05 13:00:26 2015 +0100
+@@ -29,11 +29,11 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Copyright (c) 1998-2011 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.)
+ *
+- * Last changed in libpng 1.5.0 [January 6, 2011]
++ * Last changed in libpng 1.6.8 [December 19, 2013]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+@@ -53,7 +53,7 @@
+ * (actually ((void)0)).
+ *
+ * level: level of detail of message, starting at 0. A level 'n'
+- * message is preceded by 'n' tab characters (not implemented
++ * message is preceded by 'n' 3-space indentations (not implemented
+ * on Microsoft compilers unless PNG_DEBUG_FILE is also
+ * defined, to allow debug DLL compilation with no standard IO).
+ * message: a printf(3) style text string. A trailing '\n' is added
+@@ -105,32 +105,29 @@
+ # endif /* PNG_DEBUG_FILE */
+
+ # if (PNG_DEBUG > 1)
+-/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on
+- * non-ISO compilers
+- */
+ # ifdef __STDC__
+ # ifndef png_debug
+ # define png_debug(l,m) \
+ do { \
+ int num_tabs=l; \
+- fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
+- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \
++ fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? " " : \
++ (num_tabs==2 ? " " : (num_tabs>2 ? " " : "")))); \
+ } while (0)
+ # endif
+ # ifndef png_debug1
+ # define png_debug1(l,m,p1) \
+ do { \
+ int num_tabs=l; \
+- fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
+- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \
++ fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? " " : \
++ (num_tabs==2 ? " " : (num_tabs>2 ? " " : ""))),p1); \
+ } while (0)
+ # endif
+ # ifndef png_debug2
+ # define png_debug2(l,m,p1,p2) \
+ do { \
+ int num_tabs=l; \
+- fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
+- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \
++ fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? " " : \
++ (num_tabs==2 ? " " : (num_tabs>2 ? " " : ""))),p1,p2);\
+ } while (0)
+ # endif
+ # else /* __STDC __ */
+--- ./jdk/src/share/native/sun/awt/libpng/pngerror.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngerror.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -48,14 +48,14 @@
+
+ #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
+-static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr,
++static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr,
+ png_const_charp error_message)),PNG_NORETURN);
+
+ #ifdef PNG_WARNINGS_SUPPORTED
+ static void /* PRIVATE */
+-png_default_warning PNGARG((png_structp png_ptr,
++png_default_warning PNGARG((png_const_structrp png_ptr,
+ png_const_charp warning_message));
+-#endif /* PNG_WARNINGS_SUPPORTED */
++#endif /* WARNINGS */
+
+ /* This function is called whenever there is a fatal error. This function
+ * should not be changed. If there is a need to handle errors differently,
+@@ -64,14 +64,15 @@
+ */
+ #ifdef PNG_ERROR_TEXT_SUPPORTED
+ PNG_FUNCTION(void,PNGAPI
+-png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN)
++png_error,(png_const_structrp png_ptr, png_const_charp error_message),
++ PNG_NORETURN)
+ {
+ #ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ char msg[16];
+ if (png_ptr != NULL)
+ {
+- if (png_ptr->flags&
+- (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
++ if ((png_ptr->flags &
++ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0
+ {
+ if (*error_message == PNG_LITERAL_SHARP)
+ {
+@@ -81,7 +82,7 @@
+ if (error_message[offset] == ' ')
+ break;
+
+- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
++ if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
+ {
+ int i;
+ for (i = 0; i < offset - 1; i++)
+@@ -96,7 +97,7 @@
+
+ else
+ {
+- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
++ if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
+ {
+ msg[0] = '0';
+ msg[1] = '\0';
+@@ -107,7 +108,8 @@
+ }
+ #endif
+ if (png_ptr != NULL && png_ptr->error_fn != NULL)
+- (*(png_ptr->error_fn))(png_ptr, error_message);
++ (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr),
++ error_message);
+
+ /* If the custom handler doesn't exist, or if it returns,
+ use the default handler, which will not return. */
+@@ -115,7 +117,7 @@
+ }
+ #else
+ PNG_FUNCTION(void,PNGAPI
+-png_err,(png_structp png_ptr),PNG_NORETURN)
++png_err,(png_const_structrp png_ptr),PNG_NORETURN)
+ {
+ /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed
+ * erroneously as '\0', instead of the empty string "". This was
+@@ -123,13 +125,13 @@
+ * will crash in this case.
+ */
+ if (png_ptr != NULL && png_ptr->error_fn != NULL)
+- (*(png_ptr->error_fn))(png_ptr, "");
++ (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr), "");
+
+ /* If the custom handler doesn't exist, or if it returns,
+ use the default handler, which will not return. */
+ png_default_error(png_ptr, "");
+ }
+-#endif /* PNG_ERROR_TEXT_SUPPORTED */
++#endif /* ERROR_TEXT */
+
+ /* Utility to safely appends strings to a buffer. This never errors out so
+ * error checking is not required in the caller.
+@@ -178,7 +180,7 @@
+ case PNG_NUMBER_FORMAT_fixed:
+ /* Needs five digits (the fraction) */
+ mincount = 5;
+- if (output || number % 10 != 0)
++ if (output != 0 || number % 10 != 0)
+ {
+ *--end = digits[number % 10];
+ output = 1;
+@@ -189,7 +191,7 @@
+ 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];
+@@ -199,7 +201,7 @@
+ 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];
+@@ -215,13 +217,13 @@
+ ++count;
+
+ /* Float a fixed number here: */
+- if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start)
++ if ((format == PNG_NUMBER_FORMAT_fixed) && (count == 5) && (end > start))
+ {
+ /* End of the fraction, but maybe nothing was output? In that case
+ * drop the decimal point. If the number is a true zero handle that
+ * here.
+ */
+- if (output)
++ if (output != 0)
+ *--end = '.';
+ else if (number == 0) /* and !output */
+ *--end = '0';
+@@ -239,14 +241,14 @@
+ * png_set_error_fn() to replace the warning function at run-time.
+ */
+ void PNGAPI
+-png_warning(png_structp png_ptr, png_const_charp warning_message)
++png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
+ {
+ int offset = 0;
+ if (png_ptr != NULL)
+ {
+ #ifdef PNG_ERROR_NUMBERS_SUPPORTED
+- if (png_ptr->flags&
+- (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
++ if ((png_ptr->flags &
++ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
+ #endif
+ {
+ if (*warning_message == PNG_LITERAL_SHARP)
+@@ -258,7 +260,8 @@
+ }
+ }
+ if (png_ptr != NULL && png_ptr->warning_fn != NULL)
+- (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
++ (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),
++ warning_message + offset);
+ else
+ png_default_warning(png_ptr, warning_message + offset);
+ }
+@@ -306,38 +309,43 @@
+ }
+
+ void
+-png_formatted_warning(png_structp png_ptr, png_warning_parameters p,
++png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
+ png_const_charp message)
+ {
+- /* The internal buffer is just 128 bytes - enough for all our messages,
+- * overflow doesn't happen because this code checks!
++ /* The internal buffer is just 192 bytes - enough for all our messages,
++ * overflow doesn't happen because this code checks! If someone figures
++ * out how to send us a message longer than 192 bytes, all that will
++ * happen is that the message will be truncated appropriately.
+ */
+- size_t i;
+- char msg[128];
++ size_t i = 0; /* Index in the msg[] buffer: */
++ char msg[192];
+
+- for (i=0; i<(sizeof msg)-1 && *message != '\0'; ++i)
++ /* Each iteration through the following loop writes at most one character
++ * to msg[i++] then returns here to validate that there is still space for
++ * the trailing '\0'. It may (in the case of a parameter) read more than
++ * one character from message[]; it must check for '\0' and continue to the
++ * test if it finds the end of string.
++ */
++ while (i<(sizeof msg)-1 && *message != '\0')
+ {
+- if (*message == '@')
++ /* '@' at end of string is now just printed (previously it was skipped);
++ * it is an error in the calling code to terminate the string with @.
++ */
++ if (p != NULL && *message == '@' && message[1] != '\0')
+ {
+- int parameter = -1;
+- switch (*++message)
+- {
+- case '1':
+- parameter = 0;
+- break;
++ int parameter_char = *++message; /* Consume the '@' */
++ static const char valid_parameters[] = "123456789";
++ int parameter = 0;
+
+- case '2':
+- parameter = 1;
+- break;
++ /* Search for the parameter digit, the index in the string is the
++ * parameter to use.
++ */
++ while (valid_parameters[parameter] != parameter_char &&
++ valid_parameters[parameter] != '\0')
++ ++parameter;
+
+- case '\0':
+- continue; /* To break out of the for loop above. */
+-
+- default:
+- break;
+- }
+-
+- if (parameter >= 0 && parameter < PNG_WARNING_PARAMETER_COUNT)
++ /* If the parameter digit is out of range it will just get printed. */
++ if (parameter < PNG_WARNING_PARAMETER_COUNT)
+ {
+ /* Append this parameter */
+ png_const_charp parm = p[parameter];
+@@ -347,47 +355,101 @@
+ * that parm[] has been initialized, so there is no guarantee of a
+ * trailing '\0':
+ */
+- for (; i<(sizeof msg)-1 && parm != '\0' && parm < pend; ++i)
+- msg[i] = *parm++;
++ while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend)
++ msg[i++] = *parm++;
+
++ /* Consume the parameter digit too: */
+ ++message;
+ continue;
+ }
+
+ /* else not a parameter and there is a character after the @ sign; just
+- * copy that.
++ * copy that. This is known not to be '\0' because of the test above.
+ */
+ }
+
+ /* At this point *message can't be '\0', even in the bad parameter case
+ * above where there is a lone '@' at the end of the message string.
+ */
+- msg[i] = *message++;
++ msg[i++] = *message++;
+ }
+
+ /* i is always less than (sizeof msg), so: */
+ msg[i] = '\0';
+
+- /* And this is the formatted message: */
++ /* And this is the formatted message. It may be larger than
++ * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these
++ * are not (currently) formatted.
++ */
+ png_warning(png_ptr, msg);
+ }
+-#endif /* PNG_WARNINGS_SUPPORTED */
++#endif /* WARNINGS */
+
+ #ifdef PNG_BENIGN_ERRORS_SUPPORTED
+ void PNGAPI
+-png_benign_error(png_structp png_ptr, png_const_charp error_message)
++png_benign_error(png_const_structrp png_ptr, png_const_charp error_message)
+ {
+- if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
++ if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
++ {
++# ifdef PNG_READ_SUPPORTED
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
++ png_ptr->chunk_name != 0)
++ png_chunk_warning(png_ptr, error_message);
++ else
++# endif
++ png_warning(png_ptr, error_message);
++ }
++
++ else
++ {
++# ifdef PNG_READ_SUPPORTED
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
++ png_ptr->chunk_name != 0)
++ png_chunk_error(png_ptr, error_message);
++ else
++# endif
++ png_error(png_ptr, error_message);
++ }
++
++# ifndef PNG_ERROR_TEXT_SUPPORTED
++ PNG_UNUSED(error_message)
++# endif
++}
++
++void /* PRIVATE */
++png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
++{
++ if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0)
+ png_warning(png_ptr, error_message);
+ else
+ png_error(png_ptr, error_message);
++
++# ifndef PNG_ERROR_TEXT_SUPPORTED
++ PNG_UNUSED(error_message)
++# endif
+ }
+-#endif
+
++void /* PRIVATE */
++png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
++{
++ if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
++ png_warning(png_ptr, error_message);
++ else
++ png_error(png_ptr, error_message);
++
++# ifndef PNG_ERROR_TEXT_SUPPORTED
++ PNG_UNUSED(error_message)
++# endif
++}
++#endif /* BENIGN_ERRORS */
++
++#define PNG_MAX_ERROR_TEXT 196 /* Currently limited by profile_error in png.c */
++#if defined(PNG_WARNINGS_SUPPORTED) || \
++ (defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED))
+ /* These utilities are used internally to build an error message that relates
+ * to the current chunk. The chunk name comes from png_ptr->chunk_name,
+- * this is used to prefix the message. The message is limited in length
+- * to 63 bytes, the name characters are output as hex digits wrapped in []
++ * which is used to prefix the message. The message is limited in length
++ * to 63 bytes. The name characters are output as hex digits wrapped in []
+ * if the character is invalid.
+ */
+ #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
+@@ -396,18 +458,19 @@
+ 'A', 'B', 'C', 'D', 'E', 'F'
+ };
+
+-#define PNG_MAX_ERROR_TEXT 64
+-#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
+ static void /* PRIVATE */
+-png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
++png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
+ error_message)
+ {
+- int iout = 0, iin = 0;
++ png_uint_32 chunk_name = png_ptr->chunk_name;
++ int iout = 0, ishift = 24;
+
+- while (iin < 4)
++ while (ishift >= 0)
+ {
+- int c = png_ptr->chunk_name[iin++];
+- if (isnonalpha(c))
++ int c = (int)(chunk_name >> ishift) & 0xff;
++
++ ishift -= 8;
++ if (isnonalpha(c) != 0)
+ {
+ buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
+ buffer[iout++] = png_digit[(c & 0xf0) >> 4];
+@@ -417,7 +480,7 @@
+
+ else
+ {
+- buffer[iout++] = (png_byte)c;
++ buffer[iout++] = (char)c;
+ }
+ }
+
+@@ -426,10 +489,11 @@
+
+ else
+ {
++ int iin = 0;
++
+ buffer[iout++] = ':';
+ buffer[iout++] = ' ';
+
+- iin = 0;
+ while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
+ buffer[iout++] = error_message[iin++];
+
+@@ -437,11 +501,11 @@
+ buffer[iout] = '\0';
+ }
+ }
+-#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
++#endif /* WARNINGS || ERROR_TEXT */
+
+ #if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
+ PNG_FUNCTION(void,PNGAPI
+-png_chunk_error,(png_structp png_ptr, png_const_charp error_message),
++png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),
+ PNG_NORETURN)
+ {
+ char msg[18+PNG_MAX_ERROR_TEXT];
+@@ -454,11 +518,11 @@
+ png_error(png_ptr, msg);
+ }
+ }
+-#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */
++#endif /* READ && ERROR_TEXT */
+
+ #ifdef PNG_WARNINGS_SUPPORTED
+ void PNGAPI
+-png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
++png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)
+ {
+ char msg[18+PNG_MAX_ERROR_TEXT];
+ if (png_ptr == NULL)
+@@ -470,38 +534,83 @@
+ png_warning(png_ptr, msg);
+ }
+ }
+-#endif /* PNG_WARNINGS_SUPPORTED */
++#endif /* WARNINGS */
+
+ #ifdef PNG_READ_SUPPORTED
+ #ifdef PNG_BENIGN_ERRORS_SUPPORTED
+ void PNGAPI
+-png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
++png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
++ error_message)
+ {
+- if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
++ if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
+ png_chunk_warning(png_ptr, error_message);
+
+ else
+ png_chunk_error(png_ptr, error_message);
++
++# ifndef PNG_ERROR_TEXT_SUPPORTED
++ PNG_UNUSED(error_message)
++# endif
+ }
+ #endif
+-#endif /* PNG_READ_SUPPORTED */
++#endif /* READ */
++
++void /* PRIVATE */
++png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
++{
++# ifndef PNG_WARNINGS_SUPPORTED
++ PNG_UNUSED(message)
++# endif
++
++ /* 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) != 0)
++# 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) == 0)
++# 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,
+-png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN)
++png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)
+ {
+ # define fixed_message "fixed point overflow in "
+ # define fixed_message_ln ((sizeof fixed_message)-1)
+ int iin;
+ char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
+- png_memcpy(msg, fixed_message, fixed_message_ln);
++ memcpy(msg, fixed_message, fixed_message_ln);
+ iin = 0;
+- if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
+- {
+- msg[fixed_message_ln + iin] = name[iin];
+- ++iin;
+- }
++ if (name != NULL)
++ while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
++ {
++ msg[fixed_message_ln + iin] = name[iin];
++ ++iin;
++ }
+ msg[fixed_message_ln + iin] = 0;
+ png_error(png_ptr, msg);
+ }
+@@ -513,14 +622,111 @@
+ * otherwise it is necessary for png_default_error to be overridden.
+ */
+ jmp_buf* PNGAPI
+-png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
++png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn,
+ size_t jmp_buf_size)
+ {
+- if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
++ /* From libpng 1.6.0 the app gets one chance to set a 'jmpbuf_size' value
++ * and it must not change after that. Libpng doesn't care how big the
++ * buffer is, just that it doesn't change.
++ *
++ * If the buffer size is no *larger* than the size of jmp_buf when libpng is
++ * compiled a built in jmp_buf is returned; this preserves the pre-1.6.0
++ * semantics that this call will not fail. If the size is larger, however,
++ * the buffer is allocated and this may fail, causing the function to return
++ * NULL.
++ */
++ if (png_ptr == NULL)
+ return NULL;
+
++ if (png_ptr->jmp_buf_ptr == NULL)
++ {
++ png_ptr->jmp_buf_size = 0; /* not allocated */
++
++ if (jmp_buf_size <= (sizeof png_ptr->jmp_buf_local))
++ png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local;
++
++ else
++ {
++ png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,
++ png_malloc_warn(png_ptr, jmp_buf_size));
++
++ if (png_ptr->jmp_buf_ptr == NULL)
++ return NULL; /* new NULL return on OOM */
++
++ png_ptr->jmp_buf_size = jmp_buf_size;
++ }
++ }
++
++ else /* Already allocated: check the size */
++ {
++ size_t size = png_ptr->jmp_buf_size;
++
++ if (size == 0)
++ {
++ size = (sizeof png_ptr->jmp_buf_local);
++ if (png_ptr->jmp_buf_ptr != &png_ptr->jmp_buf_local)
++ {
++ /* This is an internal error in libpng: somehow we have been left
++ * with a stack allocated jmp_buf when the application regained
++ * control. It's always possible to fix this up, but for the moment
++ * this is a png_error because that makes it easy to detect.
++ */
++ png_error(png_ptr, "Libpng jmp_buf still allocated");
++ /* png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; */
++ }
++ }
++
++ if (size != jmp_buf_size)
++ {
++ png_warning(png_ptr, "Application jmp_buf size changed");
++ return NULL; /* caller will probably crash: no choice here */
++ }
++ }
++
++ /* Finally fill in the function, now we have a satisfactory buffer. It is
++ * valid to change the function on every call.
++ */
+ png_ptr->longjmp_fn = longjmp_fn;
+- return &png_ptr->longjmp_buffer;
++ return png_ptr->jmp_buf_ptr;
++}
++
++void /* PRIVATE */
++png_free_jmpbuf(png_structrp png_ptr)
++{
++ if (png_ptr != NULL)
++ {
++ jmp_buf *jb = png_ptr->jmp_buf_ptr;
++
++ /* A size of 0 is used to indicate a local, stack, allocation of the
++ * pointer; used here and in png.c
++ */
++ if (jb != NULL && png_ptr->jmp_buf_size > 0)
++ {
++
++ /* This stuff is so that a failure to free the error control structure
++ * does not leave libpng in a state with no valid error handling: the
++ * free always succeeds, if there is an error it gets ignored.
++ */
++ if (jb != &png_ptr->jmp_buf_local)
++ {
++ /* Make an internal, libpng, jmp_buf to return here */
++ jmp_buf free_jmp_buf;
++
++ if (!setjmp(free_jmp_buf))
++ {
++ png_ptr->jmp_buf_ptr = &free_jmp_buf; /* come back here */
++ png_ptr->jmp_buf_size = 0; /* stack allocation */
++ png_ptr->longjmp_fn = longjmp;
++ png_free(png_ptr, jb); /* Return to setjmp on error */
++ }
++ }
++ }
++
++ /* *Always* cancel everything out: */
++ png_ptr->jmp_buf_size = 0;
++ png_ptr->jmp_buf_ptr = NULL;
++ png_ptr->longjmp_fn = 0;
++ }
+ }
+ #endif
+
+@@ -530,7 +736,7 @@
+ * error function pointer in png_set_error_fn().
+ */
+ static PNG_FUNCTION(void /* PRIVATE */,
+-png_default_error,(png_structp png_ptr, png_const_charp error_message),
++png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
+ PNG_NORETURN)
+ {
+ #ifdef PNG_CONSOLE_IO_SUPPORTED
+@@ -577,24 +783,23 @@
+ }
+
+ PNG_FUNCTION(void,PNGAPI
+-png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN)
++png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
+ {
+ #ifdef PNG_SETJMP_SUPPORTED
+- if (png_ptr && png_ptr->longjmp_fn)
+- {
+-# ifdef USE_FAR_KEYWORD
+- {
+- jmp_buf tmp_jmpbuf;
+- png_memcpy(tmp_jmpbuf, png_ptr->longjmp_buffer, png_sizeof(jmp_buf));
+- png_ptr->longjmp_fn(tmp_jmpbuf, val);
+- }
++ if (png_ptr != NULL && png_ptr->longjmp_fn != NULL &&
++ png_ptr->jmp_buf_ptr != NULL)
++ png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(val)
++#endif
+
+-# else
+- png_ptr->longjmp_fn(png_ptr->longjmp_buffer, val);
+-# endif
+- }
+-#endif
+- /* Here if not setjmp support or if png_ptr is null. */
++ /* If control reaches this point, png_longjmp() must not return. The only
++ * choice is to terminate the whole process (or maybe the thread); to do
++ * this the ANSI-C abort() function is used unless a different method is
++ * implemented by overriding the default configuration setting for
++ * PNG_ABORT().
++ */
+ PNG_ABORT();
+ }
+
+@@ -605,7 +810,7 @@
+ * not used, but it is passed in case it may be useful.
+ */
+ static void /* PRIVATE */
+-png_default_warning(png_structp png_ptr, png_const_charp warning_message)
++png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message)
+ {
+ #ifdef PNG_CONSOLE_IO_SUPPORTED
+ # ifdef PNG_ERROR_NUMBERS_SUPPORTED
+@@ -647,15 +852,15 @@
+ #endif
+ PNG_UNUSED(png_ptr) /* Make compiler happy */
+ }
+-#endif /* PNG_WARNINGS_SUPPORTED */
++#endif /* WARNINGS */
+
+ /* This function is called when the application wants to use another method
+ * of handling errors and warnings. Note that the error function MUST NOT
+ * return to the calling routine or serious problems will occur. The return
+- * method used in the default routine calls longjmp(png_ptr->longjmp_buffer, 1)
++ * method used in the default routine calls longjmp(png_ptr->jmp_buf_ptr, 1)
+ */
+ void PNGAPI
+-png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
++png_set_error_fn(png_structrp png_ptr, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warning_fn)
+ {
+ if (png_ptr == NULL)
+@@ -676,7 +881,7 @@
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+ png_voidp PNGAPI
+-png_get_error_ptr(png_const_structp png_ptr)
++png_get_error_ptr(png_const_structrp png_ptr)
+ {
+ if (png_ptr == NULL)
+ return NULL;
+@@ -687,7 +892,7 @@
+
+ #ifdef PNG_ERROR_NUMBERS_SUPPORTED
+ void PNGAPI
+-png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
++png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)
+ {
+ if (png_ptr != NULL)
+ {
+@@ -697,4 +902,90 @@
+ }
+ }
+ #endif
+-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
++
++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
++ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
++ /* Currently the above both depend on SETJMP_SUPPORTED, however it would be
++ * possible to implement without setjmp support just so long as there is some
++ * way to handle the error return here:
++ */
++PNG_FUNCTION(void /* PRIVATE */, (PNGCBAPI
++png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
++ PNG_NORETURN)
++{
++ const png_const_structrp png_ptr = png_nonconst_ptr;
++ png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
++
++ /* An error is always logged here, overwriting anything (typically a warning)
++ * that is already there:
++ */
++ if (image != NULL)
++ {
++ png_safecat(image->message, (sizeof image->message), 0, error_message);
++ image->warning_or_error |= PNG_IMAGE_ERROR;
++
++ /* Retrieve the jmp_buf from within the png_control, making this work for
++ * C++ compilation too is pretty tricky: C++ wants a pointer to the first
++ * element of a jmp_buf, but C doesn't tell us the type of that.
++ */
++ if (image->opaque != NULL && image->opaque->error_buf != NULL)
++ longjmp(png_control_jmp_buf(image->opaque), 1);
++
++ /* Missing longjmp buffer, the following is to help debugging: */
++ {
++ size_t pos = png_safecat(image->message, (sizeof image->message), 0,
++ "bad longjmp: ");
++ png_safecat(image->message, (sizeof image->message), pos,
++ error_message);
++ }
++ }
++
++ /* Here on an internal programming error. */
++ abort();
++}
++
++#ifdef PNG_WARNINGS_SUPPORTED
++void /* PRIVATE */ PNGCBAPI
++png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message)
++{
++ const png_const_structrp png_ptr = png_nonconst_ptr;
++ png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
++
++ /* A warning is only logged if there is no prior warning or error. */
++ if (image->warning_or_error == 0)
++ {
++ png_safecat(image->message, (sizeof image->message), 0, warning_message);
++ image->warning_or_error |= PNG_IMAGE_WARNING;
++ }
++}
++#endif
++
++int /* PRIVATE */
++png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg)
++{
++ volatile png_imagep image = image_in;
++ volatile int result;
++ volatile png_voidp saved_error_buf;
++ jmp_buf safe_jmpbuf;
++
++ /* Safely execute function(arg) with png_error returning to this function. */
++ saved_error_buf = image->opaque->error_buf;
++ result = setjmp(safe_jmpbuf) == 0;
++
++ if (result != 0)
++ {
++
++ image->opaque->error_buf = safe_jmpbuf;
++ result = function(arg);
++ }
++
++ image->opaque->error_buf = saved_error_buf;
++
++ /* And do the cleanup prior to any failure return. */
++ if (result == 0)
++ png_image_free(image);
++
++ return result;
++}
++#endif /* SIMPLIFIED READ || SIMPLIFIED_WRITE */
++#endif /* READ || WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pngget.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngget.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.1 [February 3, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -45,7 +45,7 @@
+ #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
+ png_uint_32 PNGAPI
+-png_get_valid(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ png_uint_32 flag)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+@@ -55,7 +55,7 @@
+ }
+
+ png_size_t PNGAPI
+-png_get_rowbytes(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->rowbytes);
+@@ -65,7 +65,7 @@
+
+ #ifdef PNG_INFO_IMAGE_SUPPORTED
+ png_bytepp PNGAPI
+-png_get_rows(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->row_pointers);
+@@ -77,7 +77,7 @@
+ #ifdef PNG_EASY_ACCESS_SUPPORTED
+ /* Easy access to info, added in libpng-0.99 */
+ png_uint_32 PNGAPI
+-png_get_image_width(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return info_ptr->width;
+@@ -86,7 +86,7 @@
+ }
+
+ png_uint_32 PNGAPI
+-png_get_image_height(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return info_ptr->height;
+@@ -95,7 +95,7 @@
+ }
+
+ png_byte PNGAPI
+-png_get_bit_depth(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return info_ptr->bit_depth;
+@@ -104,7 +104,7 @@
+ }
+
+ png_byte PNGAPI
+-png_get_color_type(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return info_ptr->color_type;
+@@ -113,7 +113,7 @@
+ }
+
+ png_byte PNGAPI
+-png_get_filter_type(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return info_ptr->filter_type;
+@@ -122,7 +122,7 @@
+ }
+
+ png_byte PNGAPI
+-png_get_interlace_type(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return info_ptr->interlace_type;
+@@ -131,7 +131,7 @@
+ }
+
+ png_byte PNGAPI
+-png_get_compression_type(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return info_ptr->compression_type;
+@@ -140,10 +140,12 @@
+ }
+
+ png_uint_32 PNGAPI
+-png_get_x_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
++ info_ptr)
+ {
+ #ifdef PNG_pHYs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_pHYs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function",
+ "png_get_x_pixels_per_meter");
+@@ -151,16 +153,21 @@
+ if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
+ return (info_ptr->x_pixels_per_unit);
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return (0);
+ }
+
+ png_uint_32 PNGAPI
+-png_get_y_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
++ info_ptr)
+ {
+ #ifdef PNG_pHYs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_pHYs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function",
+ "png_get_y_pixels_per_meter");
+@@ -168,16 +175,20 @@
+ if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
+ return (info_ptr->y_pixels_per_unit);
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return (0);
+ }
+
+ png_uint_32 PNGAPI
+-png_get_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ #ifdef PNG_pHYs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_pHYs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
+
+@@ -185,6 +196,9 @@
+ info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
+ return (info_ptr->x_pixels_per_unit);
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return (0);
+@@ -192,10 +206,12 @@
+
+ #ifdef PNG_FLOATING_POINT_SUPPORTED
+ float PNGAPI
+-png_get_pixel_aspect_ratio(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp
++ info_ptr)
+ {
+ #ifdef PNG_READ_pHYs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_pHYs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
+
+@@ -203,6 +219,9 @@
+ return ((float)((float)info_ptr->y_pixels_per_unit
+ /(float)info_ptr->x_pixels_per_unit));
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return ((float)0.0);
+@@ -211,14 +230,15 @@
+
+ #ifdef PNG_FIXED_POINT_SUPPORTED
+ png_fixed_point PNGAPI
+-png_get_pixel_aspect_ratio_fixed(png_const_structp png_ptr,
+- png_const_infop info_ptr)
++png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,
++ png_const_inforp info_ptr)
+ {
+ #ifdef PNG_READ_pHYs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)
+- && info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0
+- && info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX
+- && info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_pHYs) != 0 &&
++ info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 &&
++ info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX &&
++ info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
+ {
+ png_fixed_point res;
+
+@@ -228,9 +248,12 @@
+ * range of 0..2^31-1; otherwise the cast might overflow.
+ */
+ if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
+- (png_int_32)info_ptr->x_pixels_per_unit))
++ (png_int_32)info_ptr->x_pixels_per_unit) != 0)
+ return res;
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return 0;
+@@ -238,64 +261,80 @@
+ #endif
+
+ png_int_32 PNGAPI
+-png_get_x_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ #ifdef PNG_oFFs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_oFFs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
+
+ if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
+ return (info_ptr->x_offset);
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return (0);
+ }
+
+ png_int_32 PNGAPI
+-png_get_y_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ #ifdef PNG_oFFs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_oFFs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
+
+ if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
+ return (info_ptr->y_offset);
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return (0);
+ }
+
+ png_int_32 PNGAPI
+-png_get_x_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ #ifdef PNG_oFFs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_oFFs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
+
+ if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
+ return (info_ptr->x_offset);
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return (0);
+ }
+
+ png_int_32 PNGAPI
+-png_get_y_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ #ifdef PNG_oFFs_SUPPORTED
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_oFFs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
+
+ if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
+ return (info_ptr->y_offset);
+ }
++#else
++ PNG_UNUSED(png_ptr)
++ PNG_UNUSED(info_ptr)
+ #endif
+
+ return (0);
+@@ -326,7 +365,7 @@
+ */
+ png_fixed_point result;
+ if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
+- 5000))
++ 5000) != 0)
+ return result;
+
+ /* Overflow. */
+@@ -335,26 +374,26 @@
+ }
+
+ png_uint_32 PNGAPI
+-png_get_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
+ }
+
+ png_uint_32 PNGAPI
+-png_get_x_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
+ }
+
+ png_uint_32 PNGAPI
+-png_get_y_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
+ }
+
+ #ifdef PNG_FIXED_POINT_SUPPORTED
+ static png_fixed_point
+-png_fixed_inches_from_microns(png_structp png_ptr, png_int_32 microns)
++png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)
+ {
+ /* Convert from metres * 1,000,000 to inches * 100,000, meters to
+ * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
+@@ -365,8 +404,8 @@
+ }
+
+ png_fixed_point PNGAPI
+-png_get_x_offset_inches_fixed(png_structp png_ptr,
+- png_const_infop info_ptr)
++png_get_x_offset_inches_fixed(png_const_structrp png_ptr,
++ png_const_inforp info_ptr)
+ {
+ return png_fixed_inches_from_microns(png_ptr,
+ png_get_x_offset_microns(png_ptr, info_ptr));
+@@ -375,8 +414,8 @@
+
+ #ifdef PNG_FIXED_POINT_SUPPORTED
+ png_fixed_point PNGAPI
+-png_get_y_offset_inches_fixed(png_structp png_ptr,
+- png_const_infop info_ptr)
++png_get_y_offset_inches_fixed(png_const_structrp png_ptr,
++ png_const_inforp info_ptr)
+ {
+ return png_fixed_inches_from_microns(png_ptr,
+ png_get_y_offset_microns(png_ptr, info_ptr));
+@@ -385,7 +424,7 @@
+
+ #ifdef PNG_FLOATING_POINT_SUPPORTED
+ float PNGAPI
+-png_get_x_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ /* To avoid the overflow do the conversion directly in floating
+ * point.
+@@ -396,7 +435,7 @@
+
+ #ifdef PNG_FLOATING_POINT_SUPPORTED
+ float PNGAPI
+-png_get_y_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ /* To avoid the overflow do the conversion directly in floating
+ * point.
+@@ -407,12 +446,13 @@
+
+ #ifdef PNG_pHYs_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_pHYs_dpi(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+ {
+ png_uint_32 retval = 0;
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_pHYs) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "pHYs");
+
+@@ -443,15 +483,16 @@
+
+ return (retval);
+ }
+-#endif /* PNG_pHYs_SUPPORTED */
+-#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */
++#endif /* pHYs */
++#endif /* INCH_CONVERSIONS */
+
+ /* png_get_channels really belongs in here, too, but it's been around longer */
+
+-#endif /* PNG_EASY_ACCESS_SUPPORTED */
++#endif /* EASY_ACCESS */
++
+
+ png_byte PNGAPI
+-png_get_channels(png_const_structp png_ptr, png_const_infop info_ptr)
++png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->channels);
+@@ -459,22 +500,25 @@
+ return (0);
+ }
+
++#ifdef PNG_READ_SUPPORTED
+ png_const_bytep PNGAPI
+-png_get_signature(png_const_structp png_ptr, png_infop info_ptr)
++png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ if (png_ptr != NULL && info_ptr != NULL)
+ return(info_ptr->signature);
+
+ return (NULL);
+ }
++#endif
+
+ #ifdef PNG_bKGD_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_bKGD(png_const_structp png_ptr, png_infop info_ptr,
++png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_color_16p *background)
+ {
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
+- && background != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_bKGD) != 0 &&
++ background != NULL)
+ {
+ png_debug1(1, "in %s retrieval function", "bKGD");
+
+@@ -487,32 +531,95 @@
+ #endif
+
+ #ifdef PNG_cHRM_SUPPORTED
++/* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the
++ * same time to correct the rgb grayscale coefficient defaults obtained from the
++ * cHRM chunk in 1.5.4
++ */
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_cHRM(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ double *white_x, double *white_y, double *red_x, double *red_y,
+ double *green_x, double *green_y, double *blue_x, double *blue_y)
+ {
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
++ /* Quiet API change: this code used to only return the end points if a cHRM
++ * chunk was present, but the end points can also come from iCCP or sRGB
++ * chunks, so in 1.6.0 the png_get_ APIs return the end points regardless and
++ * the png_set_ APIs merely check that set end points are mutually
++ * consistent.
++ */
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "cHRM");
+
+ if (white_x != NULL)
+- *white_x = png_float(png_ptr, info_ptr->x_white, "cHRM white X");
++ *white_x = png_float(png_ptr,
++ info_ptr->colorspace.end_points_xy.whitex, "cHRM white X");
+ if (white_y != NULL)
+- *white_y = png_float(png_ptr, info_ptr->y_white, "cHRM white Y");
++ *white_y = png_float(png_ptr,
++ info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y");
+ if (red_x != NULL)
+- *red_x = png_float(png_ptr, info_ptr->x_red, "cHRM red X");
++ *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx,
++ "cHRM red X");
+ if (red_y != NULL)
+- *red_y = png_float(png_ptr, info_ptr->y_red, "cHRM red Y");
++ *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy,
++ "cHRM red Y");
+ if (green_x != NULL)
+- *green_x = png_float(png_ptr, info_ptr->x_green, "cHRM green X");
++ *green_x = png_float(png_ptr,
++ info_ptr->colorspace.end_points_xy.greenx, "cHRM green X");
+ if (green_y != NULL)
+- *green_y = png_float(png_ptr, info_ptr->y_green, "cHRM green Y");
++ *green_y = png_float(png_ptr,
++ info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y");
+ if (blue_x != NULL)
+- *blue_x = png_float(png_ptr, info_ptr->x_blue, "cHRM blue X");
++ *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex,
++ "cHRM blue X");
+ if (blue_y != NULL)
+- *blue_y = png_float(png_ptr, info_ptr->y_blue, "cHRM blue Y");
++ *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey,
++ "cHRM blue Y");
++ return (PNG_INFO_cHRM);
++ }
++
++ return (0);
++}
++
++png_uint_32 PNGAPI
++png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,
++ double *red_X, double *red_Y, double *red_Z, double *green_X,
++ double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
++ double *blue_Z)
++{
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
++ {
++ png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
++
++ if (red_X != NULL)
++ *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X,
++ "cHRM red X");
++ if (red_Y != NULL)
++ *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y,
++ "cHRM red Y");
++ if (red_Z != NULL)
++ *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z,
++ "cHRM red Z");
++ if (green_X != NULL)
++ *green_X = png_float(png_ptr,
++ info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X");
++ if (green_Y != NULL)
++ *green_Y = png_float(png_ptr,
++ info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y");
++ if (green_Z != NULL)
++ *green_Z = png_float(png_ptr,
++ info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z");
++ if (blue_X != NULL)
++ *blue_X = png_float(png_ptr,
++ info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X");
++ if (blue_Y != NULL)
++ *blue_Y = png_float(png_ptr,
++ info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y");
++ if (blue_Z != NULL)
++ *blue_Z = png_float(png_ptr,
++ info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z");
+ return (PNG_INFO_cHRM);
+ }
+
+@@ -522,31 +629,69 @@
+
+ # ifdef PNG_FIXED_POINT_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_cHRM_fixed(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
++ png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
++ png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
++ png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
++ png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
++ png_fixed_point *int_blue_Z)
++{
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
++ {
++ png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
++
++ if (int_red_X != NULL)
++ *int_red_X = info_ptr->colorspace.end_points_XYZ.red_X;
++ if (int_red_Y != NULL)
++ *int_red_Y = info_ptr->colorspace.end_points_XYZ.red_Y;
++ if (int_red_Z != NULL)
++ *int_red_Z = info_ptr->colorspace.end_points_XYZ.red_Z;
++ if (int_green_X != NULL)
++ *int_green_X = info_ptr->colorspace.end_points_XYZ.green_X;
++ if (int_green_Y != NULL)
++ *int_green_Y = info_ptr->colorspace.end_points_XYZ.green_Y;
++ if (int_green_Z != NULL)
++ *int_green_Z = info_ptr->colorspace.end_points_XYZ.green_Z;
++ if (int_blue_X != NULL)
++ *int_blue_X = info_ptr->colorspace.end_points_XYZ.blue_X;
++ if (int_blue_Y != NULL)
++ *int_blue_Y = info_ptr->colorspace.end_points_XYZ.blue_Y;
++ if (int_blue_Z != NULL)
++ *int_blue_Z = info_ptr->colorspace.end_points_XYZ.blue_Z;
++ return (PNG_INFO_cHRM);
++ }
++
++ return (0);
++}
++
++png_uint_32 PNGAPI
++png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
+ png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
+ png_fixed_point *blue_x, png_fixed_point *blue_y)
+ {
+ png_debug1(1, "in %s retrieval function", "cHRM");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
+ {
+ if (white_x != NULL)
+- *white_x = info_ptr->x_white;
++ *white_x = info_ptr->colorspace.end_points_xy.whitex;
+ if (white_y != NULL)
+- *white_y = info_ptr->y_white;
++ *white_y = info_ptr->colorspace.end_points_xy.whitey;
+ if (red_x != NULL)
+- *red_x = info_ptr->x_red;
++ *red_x = info_ptr->colorspace.end_points_xy.redx;
+ if (red_y != NULL)
+- *red_y = info_ptr->y_red;
++ *red_y = info_ptr->colorspace.end_points_xy.redy;
+ if (green_x != NULL)
+- *green_x = info_ptr->x_green;
++ *green_x = info_ptr->colorspace.end_points_xy.greenx;
+ if (green_y != NULL)
+- *green_y = info_ptr->y_green;
++ *green_y = info_ptr->colorspace.end_points_xy.greeny;
+ if (blue_x != NULL)
+- *blue_x = info_ptr->x_blue;
++ *blue_x = info_ptr->colorspace.end_points_xy.bluex;
+ if (blue_y != NULL)
+- *blue_y = info_ptr->y_blue;
++ *blue_y = info_ptr->colorspace.end_points_xy.bluey;
+ return (PNG_INFO_cHRM);
+ }
+
+@@ -556,49 +701,57 @@
+ #endif
+
+ #ifdef PNG_gAMA_SUPPORTED
+-png_uint_32 PNGFAPI
+-png_get_gAMA_fixed(png_const_structp png_ptr, png_const_infop info_ptr,
++# ifdef PNG_FIXED_POINT_SUPPORTED
++png_uint_32 PNGAPI
++png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ png_fixed_point *file_gamma)
+ {
+ png_debug1(1, "in %s retrieval function", "gAMA");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+- && file_gamma != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
++ file_gamma != NULL)
+ {
+- *file_gamma = info_ptr->gamma;
++ *file_gamma = info_ptr->colorspace.gamma;
+ return (PNG_INFO_gAMA);
+ }
+
+ return (0);
+ }
++# endif
++
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_gAMA(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ double *file_gamma)
+ {
+- png_fixed_point igamma;
+- png_uint_32 ok = png_get_gAMA_fixed(png_ptr, info_ptr, &igamma);
++ png_debug1(1, "in %s retrieval function", "gAMA(float)");
+
+- if (ok)
+- *file_gamma = png_float(png_ptr, igamma, "png_get_gAMA");
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
++ file_gamma != NULL)
++ {
++ *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,
++ "png_get_gAMA");
++ return (PNG_INFO_gAMA);
++ }
+
+- return ok;
++ return (0);
+ }
+-
+ # endif
+ #endif
+
+ #ifdef PNG_sRGB_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_sRGB(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ int *file_srgb_intent)
+ {
+ png_debug1(1, "in %s retrieval function", "sRGB");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
+- && file_srgb_intent != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_sRGB) != 0 && file_srgb_intent != NULL)
+ {
+- *file_srgb_intent = (int)info_ptr->srgb_intent;
++ *file_srgb_intent = info_ptr->colorspace.rendering_intent;
+ return (PNG_INFO_sRGB);
+ }
+
+@@ -608,22 +761,24 @@
+
+ #ifdef PNG_iCCP_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_iCCP(png_const_structp png_ptr, png_const_infop 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)
+ {
+ png_debug1(1, "in %s retrieval function", "iCCP");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
+- && name != NULL && profile != NULL && proflen != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_iCCP) != 0 &&
++ name != NULL && compression_type != NULL && profile != NULL &&
++ proflen != NULL)
+ {
+ *name = info_ptr->iccp_name;
+ *profile = info_ptr->iccp_profile;
+- /* Compression_type is a dummy so the API won't have to change
+- * if we introduce multiple compression types later.
++ *proflen = png_get_uint_32(info_ptr->iccp_profile);
++ /* This is somewhat irrelevant since the profile data returned has
++ * actually been uncompressed.
+ */
+- *proflen = (int)info_ptr->iccp_proflen;
+- *compression_type = (int)info_ptr->iccp_compression;
++ *compression_type = PNG_COMPRESSION_TYPE_BASE;
+ return (PNG_INFO_iCCP);
+ }
+
+@@ -632,14 +787,14 @@
+ #endif
+
+ #ifdef PNG_sPLT_SUPPORTED
+-png_uint_32 PNGAPI
+-png_get_sPLT(png_const_structp png_ptr, png_const_infop 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);
+@@ -648,13 +803,13 @@
+
+ #ifdef PNG_hIST_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_hIST(png_const_structp png_ptr, png_const_infop 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");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
+- && hist != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL)
+ {
+ *hist = info_ptr->hist;
+ return (PNG_INFO_hIST);
+@@ -665,11 +820,10 @@
+ #endif
+
+ png_uint_32 PNGAPI
+-png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
++png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ png_uint_32 *width, png_uint_32 *height, int *bit_depth,
+ int *color_type, int *interlace_type, int *compression_type,
+ int *filter_type)
+-
+ {
+ png_debug1(1, "in %s retrieval function", "IHDR");
+
+@@ -696,7 +850,7 @@
+ * application has ignored our advice not to mess with the members
+ * of info_ptr directly.
+ */
+- png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
++ png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,
+ info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
+ info_ptr->compression_type, info_ptr->filter_type);
+
+@@ -705,13 +859,14 @@
+
+ #ifdef PNG_oFFs_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_oFFs(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
+ {
+ png_debug1(1, "in %s retrieval function", "oFFs");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
+- && offset_x != NULL && offset_y != NULL && unit_type != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_oFFs) != 0 &&
++ offset_x != NULL && offset_y != NULL && unit_type != NULL)
+ {
+ *offset_x = info_ptr->x_offset;
+ *offset_y = info_ptr->y_offset;
+@@ -725,14 +880,15 @@
+
+ #ifdef PNG_pCAL_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_pCAL(png_const_structp png_ptr, png_const_infop 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)
+ {
+ png_debug1(1, "in %s retrieval function", "pCAL");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
+- && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_pCAL) != 0 &&
++ purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
+ nparams != NULL && units != NULL && params != NULL)
+ {
+ *purpose = info_ptr->pcal_purpose;
+@@ -751,16 +907,20 @@
+
+ #ifdef PNG_sCAL_SUPPORTED
+ # ifdef PNG_FIXED_POINT_SUPPORTED
+-# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
++# if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
++ defined(PNG_FLOATING_POINT_SUPPORTED)
+ png_uint_32 PNGAPI
+-png_get_sCAL_fixed(png_structp png_ptr, png_const_infop info_ptr,
++png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ int *unit, png_fixed_point *width, png_fixed_point *height)
+ {
+ if (png_ptr != NULL && info_ptr != NULL &&
+- (info_ptr->valid & PNG_INFO_sCAL))
++ (info_ptr->valid & PNG_INFO_sCAL) != 0)
+ {
+ *unit = info_ptr->scal_unit;
+- /*TODO: make this work without FP support */
++ /*TODO: make this work without FP support; the API is currently eliminated
++ * if neither floating point APIs nor internal floating point arithmetic
++ * are enabled.
++ */
+ *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
+ *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
+ "sCAL height");
+@@ -773,11 +933,11 @@
+ # endif /* FIXED_POINT */
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_sCAL(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ int *unit, double *width, double *height)
+ {
+ if (png_ptr != NULL && info_ptr != NULL &&
+- (info_ptr->valid & PNG_INFO_sCAL))
++ (info_ptr->valid & PNG_INFO_sCAL) != 0)
+ {
+ *unit = info_ptr->scal_unit;
+ *width = atof(info_ptr->scal_s_width);
+@@ -789,11 +949,11 @@
+ }
+ # endif /* FLOATING POINT */
+ png_uint_32 PNGAPI
+-png_get_sCAL_s(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ int *unit, png_charpp width, png_charpp height)
+ {
+ if (png_ptr != NULL && info_ptr != NULL &&
+- (info_ptr->valid & PNG_INFO_sCAL))
++ (info_ptr->valid & PNG_INFO_sCAL) != 0)
+ {
+ *unit = info_ptr->scal_unit;
+ *width = info_ptr->scal_s_width;
+@@ -807,7 +967,7 @@
+
+ #ifdef PNG_pHYs_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_pHYs(png_const_structp png_ptr, png_const_infop info_ptr,
++png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr,
+ png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
+ {
+ png_uint_32 retval = 0;
+@@ -815,7 +975,7 @@
+ png_debug1(1, "in %s retrieval function", "pHYs");
+
+ if (png_ptr != NULL && info_ptr != NULL &&
+- (info_ptr->valid & PNG_INFO_pHYs))
++ (info_ptr->valid & PNG_INFO_pHYs) != 0)
+ {
+ if (res_x != NULL)
+ {
+@@ -841,13 +1001,13 @@
+ #endif /* pHYs */
+
+ png_uint_32 PNGAPI
+-png_get_PLTE(png_const_structp png_ptr, png_const_infop 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");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
+- && palette != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL)
+ {
+ *palette = info_ptr->palette;
+ *num_palette = info_ptr->num_palette;
+@@ -860,13 +1020,13 @@
+
+ #ifdef PNG_sBIT_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_sBIT(png_const_structp png_ptr, png_infop info_ptr,
++png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_color_8p *sig_bit)
+ {
+ png_debug1(1, "in %s retrieval function", "sBIT");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
+- && sig_bit != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL)
+ {
+ *sig_bit = &(info_ptr->sig_bit);
+ return (PNG_INFO_sBIT);
+@@ -877,15 +1037,14 @@
+ #endif
+
+ #ifdef PNG_TEXT_SUPPORTED
+-png_uint_32 PNGAPI
+-png_get_text(png_const_structp png_ptr, png_const_infop 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)
+ {
+- png_debug1(1, "in %s retrieval function",
+- (png_ptr->chunk_name[0] == '\0' ? "text" :
+- (png_const_charp)png_ptr->chunk_name));
++ png_debug1(1, "in 0x%lx retrieval function",
++ (unsigned long)png_ptr->chunk_name);
+
+ if (text_ptr != NULL)
+ *text_ptr = info_ptr->text;
+@@ -893,7 +1052,7 @@
+ 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)
+@@ -905,12 +1064,13 @@
+
+ #ifdef PNG_tIME_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_tIME(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
++png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr,
++ png_timep *mod_time)
+ {
+ png_debug1(1, "in %s retrieval function", "tIME");
+
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
+- && mod_time != NULL)
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL)
+ {
+ *mod_time = &(info_ptr->mod_time);
+ return (PNG_INFO_tIME);
+@@ -922,11 +1082,12 @@
+
+ #ifdef PNG_tRNS_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_tRNS(png_const_structp png_ptr, png_infop info_ptr,
++png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
+ {
+ png_uint_32 retval = 0;
+- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
++ if (png_ptr != NULL && info_ptr != NULL &&
++ (info_ptr->valid & PNG_INFO_tRNS) != 0)
+ {
+ png_debug1(1, "in %s retrieval function", "tRNS");
+
+@@ -965,9 +1126,9 @@
+ }
+ #endif
+
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+ int PNGAPI
+-png_get_unknown_chunks(png_const_structp png_ptr, png_const_infop 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)
+@@ -982,7 +1143,7 @@
+
+ #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+ png_byte PNGAPI
+-png_get_rgb_to_gray_status (png_const_structp png_ptr)
++png_get_rgb_to_gray_status (png_const_structrp png_ptr)
+ {
+ return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
+ }
+@@ -990,71 +1151,91 @@
+
+ #ifdef PNG_USER_CHUNKS_SUPPORTED
+ png_voidp PNGAPI
+-png_get_user_chunk_ptr(png_const_structp png_ptr)
++png_get_user_chunk_ptr(png_const_structrp png_ptr)
+ {
+ return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
+ }
+ #endif
+
+ png_size_t PNGAPI
+-png_get_compression_buffer_size(png_const_structp png_ptr)
++png_get_compression_buffer_size(png_const_structrp png_ptr)
+ {
+- return (png_ptr ? png_ptr->zbuf_size : 0L);
++ if (png_ptr == NULL)
++ return 0;
++
++# ifdef PNG_WRITE_SUPPORTED
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
++# endif
++ {
++# ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++ return png_ptr->IDAT_read_size;
++# else
++ return PNG_IDAT_READ_SIZE;
++# endif
++ }
++
++# ifdef PNG_WRITE_SUPPORTED
++ else
++ return png_ptr->zbuffer_size;
++# endif
+ }
+
+-
+ #ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ /* These functions were added to libpng 1.2.6 and were enabled
+ * by default in libpng-1.4.0 */
+ png_uint_32 PNGAPI
+-png_get_user_width_max (png_const_structp png_ptr)
++png_get_user_width_max (png_const_structrp png_ptr)
+ {
+ return (png_ptr ? png_ptr->user_width_max : 0);
+ }
+
+ png_uint_32 PNGAPI
+-png_get_user_height_max (png_const_structp png_ptr)
++png_get_user_height_max (png_const_structrp png_ptr)
+ {
+ return (png_ptr ? png_ptr->user_height_max : 0);
+ }
+
+ /* This function was added to libpng 1.4.0 */
+ png_uint_32 PNGAPI
+-png_get_chunk_cache_max (png_const_structp png_ptr)
++png_get_chunk_cache_max (png_const_structrp png_ptr)
+ {
+ return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
+ }
+
+ /* This function was added to libpng 1.4.1 */
+ png_alloc_size_t PNGAPI
+-png_get_chunk_malloc_max (png_const_structp png_ptr)
++png_get_chunk_malloc_max (png_const_structrp png_ptr)
+ {
+ return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
+ }
+-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
++#endif /* SET_USER_LIMITS */
+
+ /* These functions were added to libpng 1.4.0 */
+ #ifdef PNG_IO_STATE_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_io_state (png_structp png_ptr)
++png_get_io_state (png_const_structrp png_ptr)
+ {
+ return png_ptr->io_state;
+ }
+
+ png_uint_32 PNGAPI
+-png_get_io_chunk_type (png_const_structp png_ptr)
+-{
+- return ((png_ptr->chunk_name[0] << 24) +
+- (png_ptr->chunk_name[1] << 16) +
+- (png_ptr->chunk_name[2] << 8) +
+- (png_ptr->chunk_name[3]));
+-}
+-
+-png_const_bytep PNGAPI
+-png_get_io_chunk_name (png_structp png_ptr)
++png_get_io_chunk_type (png_const_structrp png_ptr)
+ {
+ return png_ptr->chunk_name;
+ }
+-#endif /* ?PNG_IO_STATE_SUPPORTED */
++#endif /* IO_STATE */
+
+-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
++#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
++# ifdef PNG_GET_PALETTE_MAX_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
++
++#endif /* READ || WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pnginfo.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pnginfo.h Thu Feb 05 13:00:26 2015 +0100
+@@ -29,11 +29,11 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Copyright (c) 1998-2011 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.)
+ *
+- * Last changed in libpng 1.5.0 [January 6, 2011]
++ * Last changed in libpng 1.6.1 [March 28, 2013]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+@@ -83,7 +83,7 @@
+
+ struct png_info_def
+ {
+- /* the following are necessary for every PNG file */
++ /* The following are necessary for every PNG file */
+ png_uint_32 width; /* width of image in pixels (from IHDR) */
+ png_uint_32 height; /* height of image in pixels (from IHDR) */
+ png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */
+@@ -98,11 +98,17 @@
+ png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */
+ png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
+
+- /* The following is informational only on read, and not used on writes. */
++ /* The following are set by png_set_IHDR, called from the application on
++ * write, but the are never actually used by the write code.
++ */
+ png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */
+ png_byte pixel_depth; /* number of bits per pixel */
+ png_byte spare_byte; /* to align the data, and for future use */
++
++#ifdef PNG_READ_SUPPORTED
++ /* This is never set during write */
+ png_byte signature[8]; /* magic bytes read by libpng from start of file */
++#endif
+
+ /* The rest of the data is optional. If you are reading, check the
+ * valid field to see if the information in these are valid. If you
+@@ -110,18 +116,25 @@
+ * and initialize the appropriate fields below.
+ */
+
+-#if defined(PNG_gAMA_SUPPORTED)
+- /* The gAMA chunk describes the gamma characteristics of the system
+- * on which the image was created, normally in the range [1.0, 2.5].
+- * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.
++#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
++ /* png_colorspace only contains 'flags' if neither GAMMA or COLORSPACE are
++ * defined. When COLORSPACE is switched on all the colorspace-defining
++ * chunks should be enabled, when GAMMA is switched on all the gamma-defining
++ * chunks should be enabled. If this is not done it becomes possible to read
++ * inconsistent PNG files and assign a probably incorrect interpretation to
++ * the information. (In other words, by carefully choosing which chunks to
++ * recognize the system configuration can select an interpretation for PNG
++ * files containing ambiguous data and this will result in inconsistent
++ * behavior between different libpng builds!)
+ */
+- png_fixed_point gamma;
++ png_colorspace colorspace;
+ #endif
+
+-#ifdef PNG_sRGB_SUPPORTED
+- /* GR-P, 0.96a */
+- /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */
+- png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */
++#ifdef PNG_iCCP_SUPPORTED
++ /* iCCP chunk data. */
++ png_charp iccp_name; /* profile name */
++ png_bytep iccp_profile; /* International Color Consortium profile data */
++ png_uint_32 iccp_proflen; /* ICC profile data length */
+ #endif
+
+ #ifdef PNG_TEXT_SUPPORTED
+@@ -136,7 +149,7 @@
+ int num_text; /* number of comments read or comments to write */
+ int max_text; /* current size of text array */
+ png_textp text; /* array of comments read or comments to write */
+-#endif /* PNG_TEXT_SUPPORTED */
++#endif /* TEXT */
+
+ #ifdef PNG_tIME_SUPPORTED
+ /* The tIME chunk holds the last time the displayed image data was
+@@ -211,23 +224,6 @@
+ png_uint_16p hist;
+ #endif
+
+-#ifdef PNG_cHRM_SUPPORTED
+- /* The cHRM chunk describes the CIE color characteristics of the monitor
+- * on which the PNG was created. This data allows the viewer to do gamut
+- * mapping of the input image to ensure that the viewer sees the same
+- * colors in the image as the creator. Values are in the range
+- * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero.
+- */
+- png_fixed_point x_white;
+- png_fixed_point y_white;
+- png_fixed_point x_red;
+- png_fixed_point y_red;
+- png_fixed_point x_green;
+- png_fixed_point y_green;
+- png_fixed_point x_blue;
+- png_fixed_point y_blue;
+-#endif
+-
+ #ifdef PNG_pCAL_SUPPORTED
+ /* The pCAL chunk describes a transformation between the stored pixel
+ * values and original physical data values used to create the image.
+@@ -252,25 +248,20 @@
+ /* New members added in libpng-1.0.6 */
+ png_uint_32 free_me; /* flags items libpng is responsible for freeing */
+
+-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \
+- defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+ /* Storage for unknown chunks that the library doesn't recognize. */
+ png_unknown_chunkp unknown_chunks;
+- int unknown_chunks_num;
+-#endif
+
+-#ifdef PNG_iCCP_SUPPORTED
+- /* iCCP chunk data. */
+- png_charp iccp_name; /* profile name */
+- png_bytep iccp_profile; /* International Color Consortium profile data */
+- png_uint_32 iccp_proflen; /* ICC profile data length */
+- png_byte iccp_compression; /* Always zero */
++ /* 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
+--- ./jdk/src/share/native/sun/awt/libpng/pnglibconf.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pnglibconf.h Thu Feb 05 13:00:26 2015 +0100
+@@ -34,69 +34,47 @@
+ * file and, per its terms, should not be removed:
+ */
+
+-/* libpng version 1.5.4 - last changed on June 22, 2011 */
++/* libpng version 1.6.16,December 22, 2014 */
+
+-/* Copyright (c) 1998-2011 Glenn Randers-Pehrson */
++/* Copyright (c) 1998-2014 Glenn Randers-Pehrson */
+
+ /* This code is released under the libpng license. */
+ /* For conditions of distribution and use, see the disclaimer */
+ /* and license in png.h */
+
+ /* pnglibconf.h */
++/* Machine generated file: DO NOT EDIT */
+ /* Derived from: scripts/pnglibconf.dfa */
+-/* If you edit this file by hand you must obey the rules expressed in */
+-/* pnglibconf.dfa with respect to the dependencies between the following */
+-/* symbols. It is much better to generate a new file using */
+-/* scripts/libpngconf.mak */
+-
+ #ifndef PNGLCONF_H
+ #define PNGLCONF_H
+-/* settings */
+-#define PNG_API_RULE 0
+-#define PNG_CALLOC_SUPPORTED
+-#define PNG_COST_SHIFT 3
+-#define PNG_DEFAULT_READ_MACROS 1
+-#define PNG_GAMMA_THRESHOLD_FIXED 5000
+-#define PNG_MAX_GAMMA_8 11
+-#define PNG_QUANTIZE_BLUE_BITS 5
+-#define PNG_QUANTIZE_GREEN_BITS 5
+-#define PNG_QUANTIZE_RED_BITS 5
+-#define PNG_sCAL_PRECISION 5
+-#define PNG_USER_CHUNK_CACHE_MAX 0
+-#define PNG_USER_CHUNK_MALLOC_MAX 0
+-#define PNG_USER_HEIGHT_MAX 1000000L
+-#define PNG_USER_WIDTH_MAX 1000000L
+-#define PNG_WEIGHT_SHIFT 8
+-#define PNG_ZBUF_SIZE 8192
+-/* end of settings */
+ /* options */
+ #define PNG_16BIT_SUPPORTED
+-#define PNG_ALIGN_MEMORY_SUPPORTED
++#define PNG_ALIGNED_MEMORY_SUPPORTED
++/*#undef PNG_ARM_NEON_API_SUPPORTED*/
++/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/
+ #define PNG_BENIGN_ERRORS_SUPPORTED
+-#define PNG_bKGD_SUPPORTED
++#define PNG_BENIGN_READ_ERRORS_SUPPORTED
++/*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/
+ #define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
+-#define PNG_CHECK_cHRM_SUPPORTED
+-#define PNG_cHRM_SUPPORTED
++#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
++#define PNG_COLORSPACE_SUPPORTED
+ #define PNG_CONSOLE_IO_SUPPORTED
+-#define PNG_CONVERT_tIME_SUPPORTED
++/*#undef PNG_CONVERT_tIME_SUPPORTED*/
+ #define PNG_EASY_ACCESS_SUPPORTED
+ /*#undef PNG_ERROR_NUMBERS_SUPPORTED*/
+ #define PNG_ERROR_TEXT_SUPPORTED
+ #define PNG_FIXED_POINT_SUPPORTED
+ #define PNG_FLOATING_ARITHMETIC_SUPPORTED
+ #define PNG_FLOATING_POINT_SUPPORTED
+-#define PNG_gAMA_SUPPORTED
++#define PNG_FORMAT_AFIRST_SUPPORTED
++#define PNG_FORMAT_BGR_SUPPORTED
++#define PNG_GAMMA_SUPPORTED
++#define PNG_GET_PALETTE_MAX_SUPPORTED
+ #define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+-#define PNG_hIST_SUPPORTED
+-#define PNG_iCCP_SUPPORTED
+ #define PNG_INCH_CONVERSIONS_SUPPORTED
+ #define PNG_INFO_IMAGE_SUPPORTED
+ #define PNG_IO_STATE_SUPPORTED
+-#define PNG_iTXt_SUPPORTED
+ #define PNG_MNG_FEATURES_SUPPORTED
+-#define PNG_oFFs_SUPPORTED
+-#define PNG_pCAL_SUPPORTED
+-#define PNG_pHYs_SUPPORTED
+ #define PNG_POINTER_INDEXING_SUPPORTED
+ #define PNG_PROGRESSIVE_READ_SUPPORTED
+ #define PNG_READ_16BIT_SUPPORTED
+@@ -104,67 +82,73 @@
+ #define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+ #define PNG_READ_BACKGROUND_SUPPORTED
+ #define PNG_READ_BGR_SUPPORTED
+-#define PNG_READ_bKGD_SUPPORTED
+-#define PNG_READ_cHRM_SUPPORTED
++#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
+ #define PNG_READ_COMPOSITE_NODIV_SUPPORTED
+ #define PNG_READ_COMPRESSED_TEXT_SUPPORTED
+ #define PNG_READ_EXPAND_16_SUPPORTED
+ #define PNG_READ_EXPAND_SUPPORTED
+ #define PNG_READ_FILLER_SUPPORTED
+-#define PNG_READ_gAMA_SUPPORTED
+ #define PNG_READ_GAMMA_SUPPORTED
++#define PNG_READ_GET_PALETTE_MAX_SUPPORTED
+ #define PNG_READ_GRAY_TO_RGB_SUPPORTED
+-#define PNG_READ_hIST_SUPPORTED
+-#define PNG_READ_iCCP_SUPPORTED
+ #define PNG_READ_INTERLACING_SUPPORTED
+ #define PNG_READ_INT_FUNCTIONS_SUPPORTED
+ #define PNG_READ_INVERT_ALPHA_SUPPORTED
+ #define PNG_READ_INVERT_SUPPORTED
+-#define PNG_READ_iTXt_SUPPORTED
+-#define PNG_READ_oFFs_SUPPORTED
+ #define PNG_READ_OPT_PLTE_SUPPORTED
++#define PNG_READ_PACKSWAP_SUPPORTED
+ #define PNG_READ_PACK_SUPPORTED
+-#define PNG_READ_PACKSWAP_SUPPORTED
+-#define PNG_READ_pCAL_SUPPORTED
+-#define PNG_READ_pHYs_SUPPORTED
+ #define PNG_READ_QUANTIZE_SUPPORTED
+ #define PNG_READ_RGB_TO_GRAY_SUPPORTED
+-#define PNG_READ_sBIT_SUPPORTED
+ #define PNG_READ_SCALE_16_TO_8_SUPPORTED
+-#define PNG_READ_sCAL_SUPPORTED
+ #define PNG_READ_SHIFT_SUPPORTED
+-#define PNG_READ_sPLT_SUPPORTED
+-#define PNG_READ_sRGB_SUPPORTED
+ #define PNG_READ_STRIP_16_TO_8_SUPPORTED
+ #define PNG_READ_STRIP_ALPHA_SUPPORTED
+ #define PNG_READ_SUPPORTED
+ #define PNG_READ_SWAP_ALPHA_SUPPORTED
+ #define PNG_READ_SWAP_SUPPORTED
+-#define PNG_READ_tEXt_SUPPORTED
+ #define PNG_READ_TEXT_SUPPORTED
+-#define PNG_READ_tIME_SUPPORTED
+ #define PNG_READ_TRANSFORMS_SUPPORTED
+-#define PNG_READ_tRNS_SUPPORTED
+ #define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+ #define PNG_READ_USER_CHUNKS_SUPPORTED
+ #define PNG_READ_USER_TRANSFORM_SUPPORTED
++#define PNG_READ_bKGD_SUPPORTED
++#define PNG_READ_cHRM_SUPPORTED
++#define PNG_READ_gAMA_SUPPORTED
++#define PNG_READ_hIST_SUPPORTED
++#define PNG_READ_iCCP_SUPPORTED
++#define PNG_READ_iTXt_SUPPORTED
++#define PNG_READ_oFFs_SUPPORTED
++#define PNG_READ_pCAL_SUPPORTED
++#define PNG_READ_pHYs_SUPPORTED
++#define PNG_READ_sBIT_SUPPORTED
++#define PNG_READ_sCAL_SUPPORTED
++#define PNG_READ_sPLT_SUPPORTED
++#define PNG_READ_sRGB_SUPPORTED
++#define PNG_READ_tEXt_SUPPORTED
++#define PNG_READ_tIME_SUPPORTED
++#define PNG_READ_tRNS_SUPPORTED
+ #define PNG_READ_zTXt_SUPPORTED
+-#define PNG_SAVE_INT_32_SUPPORTED
+-#define PNG_sBIT_SUPPORTED
+-#define PNG_sCAL_SUPPORTED
++/*#undef PNG_SAFE_LIMITS_SUPPORTED*/
++/*#undef PNG_SAVE_INT_32_SUPPORTED*/
++#define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+ #define PNG_SEQUENTIAL_READ_SUPPORTED
++#define PNG_SETJMP_SUPPORTED
+ #define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED
+ #define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED
+-#define PNG_SETJMP_SUPPORTED
++#define PNG_SET_OPTION_SUPPORTED
++#define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
+ #define PNG_SET_USER_LIMITS_SUPPORTED
+-#define PNG_sPLT_SUPPORTED
+-#define PNG_sRGB_SUPPORTED
++#define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
++#define PNG_SIMPLIFIED_READ_BGR_SUPPORTED
++#define PNG_SIMPLIFIED_READ_SUPPORTED
++/*#undef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED*/
++/*#undef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED*/
++/*#undef PNG_SIMPLIFIED_WRITE_SUPPORTED*/
+ #define PNG_STDIO_SUPPORTED
+-#define PNG_tEXt_SUPPORTED
++#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+ #define PNG_TEXT_SUPPORTED
+ #define PNG_TIME_RFC1123_SUPPORTED
+-#define PNG_tIME_SUPPORTED
+-#define PNG_tRNS_SUPPORTED
+ #define PNG_UNKNOWN_CHUNKS_SUPPORTED
+ #define PNG_USER_CHUNKS_SUPPORTED
+ #define PNG_USER_LIMITS_SUPPORTED
+@@ -172,6 +156,91 @@
+ #define PNG_USER_TRANSFORM_INFO_SUPPORTED
+ #define PNG_USER_TRANSFORM_PTR_SUPPORTED
+ #define PNG_WARNINGS_SUPPORTED
++/*#undef PNG_WRITE_16BIT_SUPPORTED*/
++/*#undef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED*/
++/*#undef PNG_WRITE_BGR_SUPPORTED*/
++/*#undef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED*/
++/*#undef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED*/
++/*#undef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED*/
++/*#undef PNG_WRITE_FILLER_SUPPORTED*/
++/*#undef PNG_WRITE_FILTER_SUPPORTED*/
++/*#undef PNG_WRITE_FLUSH_SUPPORTED*/
++/*#undef PNG_WRITE_GET_PALETTE_MAX_SUPPORTED*/
++/*#undef PNG_WRITE_INTERLACING_SUPPORTED*/
++/*#undef PNG_WRITE_INT_FUNCTIONS_SUPPORTED*/
++/*#undef PNG_WRITE_INVERT_ALPHA_SUPPORTED*/
++/*#undef PNG_WRITE_INVERT_SUPPORTED*/
++/*#undef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED*/
++/*#undef PNG_WRITE_PACKSWAP_SUPPORTED*/
++/*#undef PNG_WRITE_PACK_SUPPORTED*/
++/*#undef PNG_WRITE_SHIFT_SUPPORTED*/
++/*#undef PNG_WRITE_SUPPORTED*/
++/*#undef PNG_WRITE_SWAP_ALPHA_SUPPORTED*/
++/*#undef PNG_WRITE_SWAP_SUPPORTED*/
++/*#undef PNG_WRITE_TEXT_SUPPORTED*/
++/*#undef PNG_WRITE_TRANSFORMS_SUPPORTED*/
++/*#undef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED*/
++/*#undef PNG_WRITE_USER_TRANSFORM_SUPPORTED*/
++/*#undef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED*/
++/*#undef PNG_WRITE_bKGD_SUPPORTED*/
++/*#undef PNG_WRITE_cHRM_SUPPORTED*/
++/*#undef PNG_WRITE_gAMA_SUPPORTED*/
++/*#undef PNG_WRITE_hIST_SUPPORTED*/
++/*#undef PNG_WRITE_iCCP_SUPPORTED*/
++/*#undef PNG_WRITE_iTXt_SUPPORTED*/
++/*#undef PNG_WRITE_oFFs_SUPPORTED*/
++/*#undef PNG_WRITE_pCAL_SUPPORTED*/
++/*#undef PNG_WRITE_pHYs_SUPPORTED*/
++/*#undef PNG_WRITE_sBIT_SUPPORTED*/
++/*#undef PNG_WRITE_sCAL_SUPPORTED*/
++/*#undef PNG_WRITE_sPLT_SUPPORTED*/
++/*#undef PNG_WRITE_sRGB_SUPPORTED*/
++/*#undef PNG_WRITE_tEXt_SUPPORTED*/
++/*#undef PNG_WRITE_tIME_SUPPORTED*/
++/*#undef PNG_WRITE_tRNS_SUPPORTED*/
++/*#undef PNG_WRITE_zTXt_SUPPORTED*/
++#define PNG_bKGD_SUPPORTED
++#define PNG_cHRM_SUPPORTED
++#define PNG_gAMA_SUPPORTED
++#define PNG_hIST_SUPPORTED
++#define PNG_iCCP_SUPPORTED
++#define PNG_iTXt_SUPPORTED
++#define PNG_oFFs_SUPPORTED
++#define PNG_pCAL_SUPPORTED
++#define PNG_pHYs_SUPPORTED
++#define PNG_sBIT_SUPPORTED
++#define PNG_sCAL_SUPPORTED
++#define PNG_sPLT_SUPPORTED
++#define PNG_sRGB_SUPPORTED
++#define PNG_tEXt_SUPPORTED
++#define PNG_tIME_SUPPORTED
++#define PNG_tRNS_SUPPORTED
+ #define PNG_zTXt_SUPPORTED
+ /* end of options */
++/* settings */
++#define PNG_API_RULE 0
++#define PNG_COST_SHIFT 3
++#define PNG_DEFAULT_READ_MACROS 1
++#define PNG_GAMMA_THRESHOLD_FIXED 5000
++#define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE
++#define PNG_INFLATE_BUF_SIZE 1024
++#define PNG_MAX_GAMMA_8 11
++#define PNG_QUANTIZE_BLUE_BITS 5
++#define PNG_QUANTIZE_GREEN_BITS 5
++#define PNG_QUANTIZE_RED_BITS 5
++#define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1)
++#define PNG_TEXT_Z_DEFAULT_STRATEGY 0
++#define PNG_USER_CHUNK_CACHE_MAX 0
++#define PNG_USER_CHUNK_MALLOC_MAX 0
++#define PNG_USER_HEIGHT_MAX 1000000
++#define PNG_USER_WIDTH_MAX 1000000
++#define PNG_WEIGHT_SHIFT 8
++#define PNG_ZBUF_SIZE 8192
++#define PNG_ZLIB_VERNUM 0
++#define PNG_Z_DEFAULT_COMPRESSION (-1)
++#define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0
++#define PNG_Z_DEFAULT_STRATEGY 1
++#define PNG_sCAL_PRECISION 5
++#define PNG_sRGB_PROFILE_CHECKS 2
++/* end of settings */
+ #endif /* PNGLCONF_H */
+--- ./jdk/src/share/native/sun/awt/libpng/pngmem.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngmem.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -48,457 +48,23 @@
+ #include "pngpriv.h"
+
+ #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
++/* Free a png_struct */
++void /* PRIVATE */
++png_destroy_png_struct(png_structrp png_ptr)
++{
++ if (png_ptr != NULL)
++ {
++ /* png_free might call png_error and may certainly call
++ * png_get_mem_ptr, so fake a temporary png_struct to support this.
++ */
++ png_struct dummy_struct = *png_ptr;
++ memset(png_ptr, 0, (sizeof *png_ptr));
++ png_free(&dummy_struct, png_ptr);
+
+-/* Borland DOS special memory handler */
+-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+-/* If you change this, be sure to change the one in png.h also */
+-
+-/* Allocate memory for a png_struct. The malloc and memset can be replaced
+- by a single call to calloc() if this is thought to improve performance. */
+-PNG_FUNCTION(png_voidp /* PRIVATE */,
+-png_create_struct,(int type),PNG_ALLOCATED)
+-{
+-# ifdef PNG_USER_MEM_SUPPORTED
+- return (png_create_struct_2(type, NULL, NULL));
+-}
+-
+-/* Alternate version of png_create_struct, for use with user-defined malloc. */
+-PNG_FUNCTION(png_voidp /* PRIVATE */,
+-png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
+- PNG_ALLOCATED)
+-{
+-# endif /* PNG_USER_MEM_SUPPORTED */
+- png_size_t size;
+- png_voidp struct_ptr;
+-
+- if (type == PNG_STRUCT_INFO)
+- size = png_sizeof(png_info);
+-
+- else if (type == PNG_STRUCT_PNG)
+- size = png_sizeof(png_struct);
+-
+- else
+- return (png_get_copyright(NULL));
+-
+-# ifdef PNG_USER_MEM_SUPPORTED
+- if (malloc_fn != NULL)
+- {
+- png_struct dummy_struct;
+- png_structp png_ptr = &dummy_struct;
+- png_ptr->mem_ptr=mem_ptr;
+- struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
+- }
+-
+- else
+-# endif /* PNG_USER_MEM_SUPPORTED */
+- struct_ptr = (png_voidp)farmalloc(size);
+- if (struct_ptr != NULL)
+- png_memset(struct_ptr, 0, size);
+-
+- return (struct_ptr);
+-}
+-
+-/* Free memory allocated by a png_create_struct() call */
+-void /* PRIVATE */
+-png_destroy_struct(png_voidp struct_ptr)
+-{
+-# ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2(struct_ptr, NULL, NULL);
+-}
+-
+-/* Free memory allocated by a png_create_struct() call */
+-void /* PRIVATE */
+-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+- png_voidp mem_ptr)
+-{
+-# endif
+- if (struct_ptr != NULL)
+- {
+-# ifdef PNG_USER_MEM_SUPPORTED
+- if (free_fn != NULL)
+- {
+- png_struct dummy_struct;
+- png_structp png_ptr = &dummy_struct;
+- png_ptr->mem_ptr=mem_ptr;
+- (*(free_fn))(png_ptr, struct_ptr);
+- return;
+- }
+-
+-# endif /* PNG_USER_MEM_SUPPORTED */
+- farfree (struct_ptr);
+- }
+-}
+-
+-/* Allocate memory. For reasonable files, size should never exceed
+- * 64K. However, zlib may allocate more then 64K if you don't tell
+- * it not to. See zconf.h and png.h for more information. zlib does
+- * need to allocate exactly 64K, so whatever you call here must
+- * have the ability to do that.
+- *
+- * Borland seems to have a problem in DOS mode for exactly 64K.
+- * It gives you a segment with an offset of 8 (perhaps to store its
+- * memory stuff). zlib doesn't like this at all, so we have to
+- * detect and deal with it. This code should not be needed in
+- * Windows or OS/2 modes, and only in 16 bit mode. This code has
+- * been updated by Alexander Lehmann for version 0.89 to waste less
+- * memory.
+- *
+- * Note that we can't use png_size_t for the "size" declaration,
+- * since on some systems a png_size_t is a 16-bit quantity, and as a
+- * result, we would be truncating potentially larger memory requests
+- * (which should cause a fatal error) and introducing major problems.
+- */
+-PNG_FUNCTION(png_voidp,PNGAPI
+-png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+-{
+- png_voidp ret;
+-
+- ret = (png_malloc(png_ptr, size));
+-
+- if (ret != NULL)
+- png_memset(ret,0,(png_size_t)size);
+-
+- return (ret);
+-}
+-
+-PNG_FUNCTION(png_voidp,PNGAPI
+-png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+-{
+- png_voidp ret;
+-
+- if (png_ptr == NULL || size == 0)
+- return (NULL);
+-
+-# ifdef PNG_USER_MEM_SUPPORTED
+- if (png_ptr->malloc_fn != NULL)
+- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+-
+- else
+- ret = (png_malloc_default(png_ptr, size));
+-
+- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Out of memory");
+-
+- return (ret);
+-}
+-
+-PNG_FUNCTION(png_voidp,PNGAPI
+-png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+-{
+- png_voidp ret;
+-# endif /* PNG_USER_MEM_SUPPORTED */
+-
+- if (png_ptr == NULL || size == 0)
+- return (NULL);
+-
+-# ifdef PNG_MAX_MALLOC_64K
+- if (size > (png_uint_32)65536L)
+- {
+- png_warning(png_ptr, "Cannot Allocate > 64K");
+- ret = NULL;
+- }
+-
+- else
+-# endif
+-
+- if (size != (size_t)size)
+- ret = NULL;
+-
+- else if (size == (png_uint_32)65536L)
+- {
+- if (png_ptr->offset_table == NULL)
+- {
+- /* Try to see if we need to do any of this fancy stuff */
+- ret = farmalloc(size);
+- if (ret == NULL || ((png_size_t)ret & 0xffff))
+- {
+- int num_blocks;
+- png_uint_32 total_size;
+- png_bytep table;
+- int i, mem_level, window_bits;
+- png_byte huge * hptr;
+- int window_bits
+-
+- if (ret != NULL)
+- {
+- farfree(ret);
+- ret = NULL;
+- }
+-
+- window_bits =
+- png_ptr->zlib_window_bits >= png_ptr->zlib_text_window_bits ?
+- png_ptr->zlib_window_bits : png_ptr->zlib_text_window_bits;
+-
+- if (window_bits > 14)
+- num_blocks = (int)(1 << (window_bits - 14));
+-
+- else
+- num_blocks = 1;
+-
+- mem_level =
+- png_ptr->zlib_mem_level >= png_ptr->zlib_text_mem_level ?
+- png_ptr->zlib_mem_level : png_ptr->zlib_text_mem_level;
+-
+- if (mem_level >= 7)
+- num_blocks += (int)(1 << (mem_level - 7));
+-
+- else
+- num_blocks++;
+-
+- total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
+-
+- table = farmalloc(total_size);
+-
+- if (table == NULL)
+- {
+-# ifndef PNG_USER_MEM_SUPPORTED
+- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */
+-
+- else
+- png_warning(png_ptr, "Out Of Memory");
+-# endif
+- return (NULL);
+- }
+-
+- if ((png_size_t)table & 0xfff0)
+- {
+-# ifndef PNG_USER_MEM_SUPPORTED
+- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr,
+- "Farmalloc didn't return normalized pointer");
+-
+- else
+- png_warning(png_ptr,
+- "Farmalloc didn't return normalized pointer");
+-# endif
+- return (NULL);
+- }
+-
+- png_ptr->offset_table = table;
+- png_ptr->offset_table_ptr = farmalloc(num_blocks *
+- png_sizeof(png_bytep));
+-
+- if (png_ptr->offset_table_ptr == NULL)
+- {
+-# ifndef PNG_USER_MEM_SUPPORTED
+- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */
+-
+- else
+- png_warning(png_ptr, "Out Of memory");
+-# endif
+- return (NULL);
+- }
+-
+- hptr = (png_byte huge *)table;
+- if ((png_size_t)hptr & 0xf)
+- {
+- hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+- hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */
+- }
+-
+- for (i = 0; i < num_blocks; i++)
+- {
+- png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+- hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */
+- }
+-
+- png_ptr->offset_table_number = num_blocks;
+- png_ptr->offset_table_count = 0;
+- png_ptr->offset_table_count_free = 0;
+- }
+- }
+-
+- if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
+- {
+-# ifndef PNG_USER_MEM_SUPPORTED
+- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Out of Memory"); /* Note "O" and "M" */
+-
+- else
+- png_warning(png_ptr, "Out of Memory");
+-# endif
+- return (NULL);
+- }
+-
+- ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
+- }
+-
+- else
+- ret = farmalloc(size);
+-
+-# ifndef PNG_USER_MEM_SUPPORTED
+- if (ret == NULL)
+- {
+- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */
+-
+- else
+- png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */
+- }
+-# endif
+-
+- return (ret);
+-}
+-
+-/* Free a pointer allocated by png_malloc(). In the default
+- * configuration, png_ptr is not used, but is passed in case it
+- * is needed. If ptr is NULL, return without taking any action.
+- */
+-void PNGAPI
+-png_free(png_structp png_ptr, png_voidp ptr)
+-{
+- if (png_ptr == NULL || ptr == NULL)
+- return;
+-
+-# ifdef PNG_USER_MEM_SUPPORTED
+- if (png_ptr->free_fn != NULL)
+- {
+- (*(png_ptr->free_fn))(png_ptr, ptr);
+- return;
+- }
+-
+- else
+- png_free_default(png_ptr, ptr);
+-}
+-
+-void PNGAPI
+-png_free_default(png_structp png_ptr, png_voidp ptr)
+-{
+-# endif /* PNG_USER_MEM_SUPPORTED */
+-
+- if (png_ptr == NULL || ptr == NULL)
+- return;
+-
+- if (png_ptr->offset_table != NULL)
+- {
+- int i;
+-
+- for (i = 0; i < png_ptr->offset_table_count; i++)
+- {
+- if (ptr == png_ptr->offset_table_ptr[i])
+- {
+- ptr = NULL;
+- png_ptr->offset_table_count_free++;
+- break;
+- }
+- }
+- if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
+- {
+- farfree(png_ptr->offset_table);
+- farfree(png_ptr->offset_table_ptr);
+- png_ptr->offset_table = NULL;
+- png_ptr->offset_table_ptr = NULL;
+- }
+- }
+-
+- if (ptr != NULL)
+- farfree(ptr);
+-}
+-
+-#else /* Not the Borland DOS special memory handler */
+-
+-/* Allocate memory for a png_struct or a png_info. The malloc and
+- memset can be replaced by a single call to calloc() if this is thought
+- to improve performance noticably. */
+-PNG_FUNCTION(png_voidp /* PRIVATE */,
+-png_create_struct,(int type),PNG_ALLOCATED)
+-{
+-# ifdef PNG_USER_MEM_SUPPORTED
+- return (png_create_struct_2(type, NULL, NULL));
+-}
+-
+-/* Allocate memory for a png_struct or a png_info. The malloc and
+- memset can be replaced by a single call to calloc() if this is thought
+- to improve performance noticably. */
+-PNG_FUNCTION(png_voidp /* PRIVATE */,
+-png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
+- PNG_ALLOCATED)
+-{
+-# endif /* PNG_USER_MEM_SUPPORTED */
+- png_size_t size;
+- png_voidp struct_ptr;
+-
+- if (type == PNG_STRUCT_INFO)
+- size = png_sizeof(png_info);
+-
+- else if (type == PNG_STRUCT_PNG)
+- size = png_sizeof(png_struct);
+-
+- else
+- return (NULL);
+-
+-# ifdef PNG_USER_MEM_SUPPORTED
+- if (malloc_fn != NULL)
+- {
+- png_struct dummy_struct;
+- png_structp png_ptr = &dummy_struct;
+- png_ptr->mem_ptr=mem_ptr;
+- struct_ptr = (*(malloc_fn))(png_ptr, size);
+-
+- if (struct_ptr != NULL)
+- png_memset(struct_ptr, 0, size);
+-
+- return (struct_ptr);
+- }
+-# endif /* PNG_USER_MEM_SUPPORTED */
+-
+-# if defined(__TURBOC__) && !defined(__FLAT__)
+- struct_ptr = (png_voidp)farmalloc(size);
+-# else
+-# if defined(_MSC_VER) && defined(MAXSEG_64K)
+- struct_ptr = (png_voidp)halloc(size, 1);
+-# else
+- struct_ptr = (png_voidp)malloc(size);
+-# endif
+-# endif
+-
+- if (struct_ptr != NULL)
+- png_memset(struct_ptr, 0, size);
+-
+- return (struct_ptr);
+-}
+-
+-
+-/* Free memory allocated by a png_create_struct() call */
+-void /* PRIVATE */
+-png_destroy_struct(png_voidp struct_ptr)
+-{
+-# ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2(struct_ptr, NULL, NULL);
+-}
+-
+-/* Free memory allocated by a png_create_struct() call */
+-void /* PRIVATE */
+-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+- png_voidp mem_ptr)
+-{
+-# endif /* PNG_USER_MEM_SUPPORTED */
+- if (struct_ptr != NULL)
+- {
+-# ifdef PNG_USER_MEM_SUPPORTED
+- if (free_fn != NULL)
+- {
+- png_struct dummy_struct;
+- png_structp png_ptr = &dummy_struct;
+- png_ptr->mem_ptr=mem_ptr;
+- (*(free_fn))(png_ptr, struct_ptr);
+- return;
+- }
+-# endif /* PNG_USER_MEM_SUPPORTED */
+-# if defined(__TURBOC__) && !defined(__FLAT__)
+- farfree(struct_ptr);
+-
+-# else
+-# if defined(_MSC_VER) && defined(MAXSEG_64K)
+- hfree(struct_ptr);
+-
+-# else
+- free(struct_ptr);
+-
+-# endif
+-# endif
++# ifdef PNG_SETJMP_SUPPORTED
++ /* We may have a jmp_buf left to deallocate. */
++ png_free_jmpbuf(&dummy_struct);
++# endif
+ }
+ }
+
+@@ -508,167 +74,215 @@
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ */
+-
+ PNG_FUNCTION(png_voidp,PNGAPI
+-png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
++png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+ {
+ png_voidp ret;
+
+- ret = (png_malloc(png_ptr, size));
++ ret = png_malloc(png_ptr, size);
+
+ if (ret != NULL)
+- png_memset(ret,0,(png_size_t)size);
++ memset(ret, 0, size);
+
+- return (ret);
++ return ret;
+ }
+
++/* png_malloc_base, an internal function added at libpng 1.6.0, does the work of
++ * allocating memory, taking into account limits and PNG_USER_MEM_SUPPORTED.
++ * Checking and error handling must happen outside this routine; it returns NULL
++ * if the allocation cannot be done (for any reason.)
++ */
++PNG_FUNCTION(png_voidp /* PRIVATE */,
++png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
++ PNG_ALLOCATED)
++{
++ /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS
++ * allocators have also been removed in 1.6.0, so any 16-bit system now has
++ * to implement a user memory handler. This checks to be sure it isn't
++ * called with big numbers.
++ */
++#ifndef PNG_USER_MEM_SUPPORTED
++ PNG_UNUSED(png_ptr)
++#endif
++
++ if (size > 0 && size <= PNG_SIZE_MAX
++# ifdef PNG_MAX_MALLOC_64K
++ && size <= 65536U
++# endif
++ )
++ {
++#ifdef PNG_USER_MEM_SUPPORTED
++ if (png_ptr != NULL && png_ptr->malloc_fn != NULL)
++ return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);
++
++ else
++#endif
++ return malloc((size_t)size); /* checked for truncation above */
++ }
++
++ else
++ return NULL;
++}
++
++#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\
++ defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED)
++/* 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 */
++}
++#endif /* TEXT || sPLT || STORE_UNKNOWN_CHUNKS */
++
++/* 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.
++ */
+ PNG_FUNCTION(png_voidp,PNGAPI
+-png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
++png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+ {
+ png_voidp ret;
+
+-# ifdef PNG_USER_MEM_SUPPORTED
+- if (png_ptr == NULL || size == 0)
+- return (NULL);
++ if (png_ptr == NULL)
++ return NULL;
+
+- if (png_ptr->malloc_fn != NULL)
+- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
++ ret = png_malloc_base(png_ptr, size);
+
+- else
+- ret = (png_malloc_default(png_ptr, size));
++ if (ret == NULL)
++ png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */
+
+- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Out of Memory");
+-
+- return (ret);
++ return ret;
+ }
+
++#ifdef PNG_USER_MEM_SUPPORTED
+ PNG_FUNCTION(png_voidp,PNGAPI
+-png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
++png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
++ PNG_ALLOCATED PNG_DEPRECATED)
+ {
+ png_voidp ret;
+-# endif /* PNG_USER_MEM_SUPPORTED */
+
+- if (png_ptr == NULL || size == 0)
+- return (NULL);
++ if (png_ptr == NULL)
++ return NULL;
+
+-# ifdef PNG_MAX_MALLOC_64K
+- if (size > (png_uint_32)65536L)
++ /* Passing 'NULL' here bypasses the application provided memory handler. */
++ ret = png_malloc_base(NULL/*use malloc*/, size);
++
++ if (ret == NULL)
++ png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */
++
++ return ret;
++}
++#endif /* USER_MEM */
++
++/* This function was added at libpng version 1.2.3. The png_malloc_warn()
++ * function will issue a png_warning and return NULL instead of issuing a
++ * png_error, if it fails to allocate the requested memory.
++ */
++PNG_FUNCTION(png_voidp,PNGAPI
++png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size),
++ PNG_ALLOCATED)
++{
++ if (png_ptr != NULL)
+ {
+-# ifndef PNG_USER_MEM_SUPPORTED
+- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Cannot Allocate > 64K");
++ png_voidp ret = png_malloc_base(png_ptr, size);
+
+- else
+-# endif
+- return NULL;
++ if (ret != NULL)
++ return ret;
++
++ png_warning(png_ptr, "Out of memory");
+ }
+-# endif
+
+- /* Check for overflow */
+-# if defined(__TURBOC__) && !defined(__FLAT__)
+-
+- if (size != (unsigned long)size)
+- ret = NULL;
+-
+- else
+- ret = farmalloc(size);
+-
+-# else
+-# if defined(_MSC_VER) && defined(MAXSEG_64K)
+- if (size != (unsigned long)size)
+- ret = NULL;
+-
+- else
+- ret = halloc(size, 1);
+-
+-# else
+- if (size != (size_t)size)
+- ret = NULL;
+-
+- else
+- ret = malloc((size_t)size);
+-# endif
+-# endif
+-
+-# ifndef PNG_USER_MEM_SUPPORTED
+- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+- png_error(png_ptr, "Out of Memory");
+-# endif
+-
+- return (ret);
++ return NULL;
+ }
+
+ /* Free a pointer allocated by png_malloc(). If ptr is NULL, return
+ * without taking any action.
+ */
+ void PNGAPI
+-png_free(png_structp png_ptr, png_voidp ptr)
++png_free(png_const_structrp png_ptr, png_voidp ptr)
+ {
+ if (png_ptr == NULL || ptr == NULL)
+ return;
+
+-# ifdef PNG_USER_MEM_SUPPORTED
++#ifdef PNG_USER_MEM_SUPPORTED
+ if (png_ptr->free_fn != NULL)
+- {
+- (*(png_ptr->free_fn))(png_ptr, ptr);
+- return;
+- }
++ png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);
+
+ else
+ png_free_default(png_ptr, ptr);
+ }
+
+-void PNGAPI
+-png_free_default(png_structp png_ptr, png_voidp ptr)
++PNG_FUNCTION(void,PNGAPI
++png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)
+ {
+ if (png_ptr == NULL || ptr == NULL)
+ return;
++#endif /* USER_MEM */
+
+-# endif /* PNG_USER_MEM_SUPPORTED */
+-
+-# if defined(__TURBOC__) && !defined(__FLAT__)
+- farfree(ptr);
+-
+-# else
+-# if defined(_MSC_VER) && defined(MAXSEG_64K)
+- hfree(ptr);
+-
+-# else
+ free(ptr);
+-
+-# endif
+-# endif
+ }
+-#endif /* Not Borland DOS special memory handler */
+-
+-/* This function was added at libpng version 1.2.3. The png_malloc_warn()
+- * function will set up png_malloc() to issue a png_warning and return NULL
+- * instead of issuing a png_error, if it fails to allocate the requested
+- * memory.
+- */
+-PNG_FUNCTION(png_voidp,PNGAPI
+-png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+-{
+- png_voidp ptr;
+- png_uint_32 save_flags;
+- if (png_ptr == NULL)
+- return (NULL);
+-
+- save_flags = png_ptr->flags;
+- png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+- ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
+- png_ptr->flags=save_flags;
+- return(ptr);
+-}
+-
+
+ #ifdef PNG_USER_MEM_SUPPORTED
+ /* This function is called when the application wants to use another method
+ * of allocating and freeing memory.
+ */
+ void PNGAPI
+-png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
++png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr
+ malloc_fn, png_free_ptr free_fn)
+ {
+ if (png_ptr != NULL)
+@@ -684,12 +298,12 @@
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+ png_voidp PNGAPI
+-png_get_mem_ptr(png_const_structp png_ptr)
++png_get_mem_ptr(png_const_structrp png_ptr)
+ {
+ if (png_ptr == NULL)
+- return (NULL);
++ return NULL;
+
+- return ((png_voidp)png_ptr->mem_ptr);
++ return png_ptr->mem_ptr;
+ }
+-#endif /* PNG_USER_MEM_SUPPORTED */
+-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
++#endif /* USER_MEM */
++#endif /* READ || WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pngpread.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngpread.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.2 [March 31, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -54,8 +54,15 @@
+ #define PNG_READ_iTXt_MODE 7
+ #define PNG_ERROR_MODE 8
+
++#define PNG_PUSH_SAVE_BUFFER_IF_FULL \
++if (png_ptr->push_length + 4 > png_ptr->buffer_size) \
++ { png_push_save_buffer(png_ptr); return; }
++#define PNG_PUSH_SAVE_BUFFER_IF_LT(N) \
++if (png_ptr->buffer_size < N) \
++ { png_push_save_buffer(png_ptr); return; }
++
+ void PNGAPI
+-png_process_data(png_structp png_ptr, png_infop info_ptr,
++png_process_data(png_structrp png_ptr, png_inforp info_ptr,
+ png_bytep buffer, png_size_t buffer_size)
+ {
+ if (png_ptr == NULL || info_ptr == NULL)
+@@ -70,14 +77,14 @@
+ }
+
+ png_size_t PNGAPI
+-png_process_data_pause(png_structp png_ptr, int save)
++png_process_data_pause(png_structrp png_ptr, int save)
+ {
+ if (png_ptr != NULL)
+ {
+- /* It's easiest for the caller if we do the save, then the caller doesn't
++ /* It's easiest for the caller if we do the save; then the caller doesn't
+ * have to supply the same data again:
+ */
+- if (save)
++ if (save != 0)
+ png_push_save_buffer(png_ptr);
+ else
+ {
+@@ -97,7 +104,7 @@
+ }
+
+ png_uint_32 PNGAPI
+-png_process_data_skip(png_structp png_ptr)
++png_process_data_skip(png_structrp png_ptr)
+ {
+ png_uint_32 remaining = 0;
+
+@@ -131,7 +138,7 @@
+ * doing before we ran out of data...
+ */
+ void /* PRIVATE */
+-png_process_some_data(png_structp png_ptr, png_infop info_ptr)
++png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
+ {
+ if (png_ptr == NULL)
+ return;
+@@ -156,30 +163,6 @@
+ break;
+ }
+
+-#ifdef PNG_READ_tEXt_SUPPORTED
+- case PNG_READ_tEXt_MODE:
+- {
+- png_push_read_tEXt(png_ptr, info_ptr);
+- break;
+- }
+-
+-#endif
+-#ifdef PNG_READ_zTXt_SUPPORTED
+- case PNG_READ_zTXt_MODE:
+- {
+- png_push_read_zTXt(png_ptr, info_ptr);
+- break;
+- }
+-
+-#endif
+-#ifdef PNG_READ_iTXt_SUPPORTED
+- case PNG_READ_iTXt_MODE:
+- {
+- png_push_read_iTXt(png_ptr, info_ptr);
+- break;
+- }
+-
+-#endif
+ case PNG_SKIP_MODE:
+ {
+ png_push_crc_finish(png_ptr);
+@@ -201,9 +184,9 @@
+ * routine.
+ */
+ void /* PRIVATE */
+-png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
++png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
+ {
+- png_size_t num_checked = png_ptr->sig_bytes,
++ png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */
+ num_to_check = 8 - num_checked;
+
+ if (png_ptr->buffer_size < num_to_check)
+@@ -234,114 +217,75 @@
+ }
+
+ void /* PRIVATE */
+-png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
++png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
+ {
+- PNG_IHDR;
+- PNG_IDAT;
+- PNG_IEND;
+- PNG_PLTE;
+-#ifdef PNG_READ_bKGD_SUPPORTED
+- PNG_bKGD;
+-#endif
+-#ifdef PNG_READ_cHRM_SUPPORTED
+- PNG_cHRM;
+-#endif
+-#ifdef PNG_READ_gAMA_SUPPORTED
+- PNG_gAMA;
+-#endif
+-#ifdef PNG_READ_hIST_SUPPORTED
+- PNG_hIST;
+-#endif
+-#ifdef PNG_READ_iCCP_SUPPORTED
+- PNG_iCCP;
+-#endif
+-#ifdef PNG_READ_iTXt_SUPPORTED
+- PNG_iTXt;
+-#endif
+-#ifdef PNG_READ_oFFs_SUPPORTED
+- PNG_oFFs;
+-#endif
+-#ifdef PNG_READ_pCAL_SUPPORTED
+- PNG_pCAL;
+-#endif
+-#ifdef PNG_READ_pHYs_SUPPORTED
+- PNG_pHYs;
+-#endif
+-#ifdef PNG_READ_sBIT_SUPPORTED
+- PNG_sBIT;
+-#endif
+-#ifdef PNG_READ_sCAL_SUPPORTED
+- PNG_sCAL;
+-#endif
+-#ifdef PNG_READ_sRGB_SUPPORTED
+- PNG_sRGB;
+-#endif
+-#ifdef PNG_READ_sPLT_SUPPORTED
+- PNG_sPLT;
+-#endif
+-#ifdef PNG_READ_tEXt_SUPPORTED
+- PNG_tEXt;
+-#endif
+-#ifdef PNG_READ_tIME_SUPPORTED
+- PNG_tIME;
+-#endif
+-#ifdef PNG_READ_tRNS_SUPPORTED
+- PNG_tRNS;
+-#endif
+-#ifdef PNG_READ_zTXt_SUPPORTED
+- PNG_zTXt;
++ png_uint_32 chunk_name;
++#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++ int keep; /* unknown handling method */
+ #endif
+
+- /* First we make sure we have enough data for the 4 byte chunk name
+- * and the 4 byte chunk length before proceeding with decoding the
++ /* First we make sure we have enough data for the 4-byte chunk name
++ * and the 4-byte chunk length before proceeding with decoding the
+ * chunk data. To fully decode each of these chunks, we also make
+- * sure we have enough data in the buffer for the 4 byte CRC at the
++ * sure we have enough data in the buffer for the 4-byte CRC at the
+ * end of every chunk (except IDAT, which is handled separately).
+ */
+- if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
++ if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
+ {
+ png_byte chunk_length[4];
++ png_byte chunk_tag[4];
+
+- if (png_ptr->buffer_size < 8)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_LT(8)
+ png_push_fill_buffer(png_ptr, chunk_length, 4);
+ png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
+ png_reset_crc(png_ptr);
+- png_crc_read(png_ptr, png_ptr->chunk_name, 4);
++ png_crc_read(png_ptr, chunk_tag, 4);
++ png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
+ png_check_chunk_name(png_ptr, png_ptr->chunk_name);
+ png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
+ }
+
+- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+- if (png_ptr->mode & PNG_AFTER_IDAT)
++ chunk_name = png_ptr->chunk_name;
++
++ if (chunk_name == png_IDAT)
++ {
++ if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
+ png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
+
+- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
++ /* If we reach an IDAT chunk, this means we have read all of the
++ * header chunks, and we can start reading the image (or if this
++ * is called after the image has been read - we have an error).
++ */
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_error(png_ptr, "Missing IHDR before IDAT");
++
++ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
++ (png_ptr->mode & PNG_HAVE_PLTE) == 0)
++ png_error(png_ptr, "Missing PLTE before IDAT");
++
++ png_ptr->mode |= PNG_HAVE_IDAT;
++ png_ptr->process_mode = PNG_READ_IDAT_MODE;
++
++ if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0)
++ if (png_ptr->push_length == 0)
++ return;
++
++ if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
++ png_benign_error(png_ptr, "Too many IDATs found");
++ }
++
++ if (chunk_name == png_IHDR)
+ {
+ if (png_ptr->push_length != 13)
+ png_error(png_ptr, "Invalid IHDR length");
+
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+- else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
++ else if (chunk_name == png_IEND)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
+
+ png_ptr->process_mode = PNG_READ_DONE_MODE;
+@@ -349,70 +293,25 @@
+ }
+
+ #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
++ else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
++ png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);
+
+- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+- png_ptr->mode |= PNG_HAVE_IDAT;
++ if (chunk_name == png_PLTE)
++ png_ptr->mode |= PNG_HAVE_PLTE;
++ }
++#endif
+
+- png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
+-
+- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
+- png_ptr->mode |= PNG_HAVE_PLTE;
+-
+- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+- {
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before IDAT");
+-
+- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+- !(png_ptr->mode & PNG_HAVE_PLTE))
+- png_error(png_ptr, "Missing PLTE before IDAT");
+- }
+- }
+-
+-#endif
+- else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
++ else if (chunk_name == png_PLTE)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
++ else if (chunk_name == png_IDAT)
+ {
+- /* If we reach an IDAT chunk, this means we have read all of the
+- * header chunks, and we can start reading the image (or if this
+- * is called after the image has been read - we have an error).
+- */
+-
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before IDAT");
+-
+- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+- !(png_ptr->mode & PNG_HAVE_PLTE))
+- png_error(png_ptr, "Missing PLTE before IDAT");
+-
+- if (png_ptr->mode & PNG_HAVE_IDAT)
+- {
+- if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+- if (png_ptr->push_length == 0)
+- return;
+-
+- if (png_ptr->mode & PNG_AFTER_IDAT)
+- png_benign_error(png_ptr, "Too many IDATs found");
+- }
+-
+ png_ptr->idat_size = png_ptr->push_length;
+- png_ptr->mode |= PNG_HAVE_IDAT;
+ png_ptr->process_mode = PNG_READ_IDAT_MODE;
+ png_push_have_info(png_ptr, info_ptr);
+ png_ptr->zstream.avail_out =
+@@ -423,250 +322,162 @@
+ }
+
+ #ifdef PNG_READ_gAMA_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
++ else if (png_ptr->chunk_name == png_gAMA)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_sBIT_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
++ else if (png_ptr->chunk_name == png_sBIT)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_cHRM_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
++ else if (png_ptr->chunk_name == png_cHRM)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_sRGB_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
++ else if (chunk_name == png_sRGB)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_iCCP_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
++ else if (png_ptr->chunk_name == png_iCCP)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_sPLT_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
++ else if (chunk_name == png_sPLT)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_tRNS_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
++ else if (chunk_name == png_tRNS)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_bKGD_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
++ else if (chunk_name == png_bKGD)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_hIST_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
++ else if (chunk_name == png_hIST)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_pHYs_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
++ else if (chunk_name == png_pHYs)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_oFFs_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
++ else if (chunk_name == png_oFFs)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
+ }
+ #endif
+
+ #ifdef PNG_READ_pCAL_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
++ else if (chunk_name == png_pCAL)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_sCAL_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
++ else if (chunk_name == png_sCAL)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_tIME_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
++ else if (chunk_name == png_tIME)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
+ png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_tEXt_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
++ else if (chunk_name == png_tEXt)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
+- png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
++ png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_zTXt_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
++ else if (chunk_name == png_zTXt)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
+- png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
++ png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
+ }
+
+ #endif
+ #ifdef PNG_READ_iTXt_SUPPORTED
+- else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
++ else if (chunk_name == png_iTXt)
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
++ png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
++ }
++#endif
+
+- png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
+- }
+-
+-#endif
+ else
+ {
+- if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+- png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
++ PNG_PUSH_SAVE_BUFFER_IF_FULL
++ png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,
++ PNG_HANDLE_CHUNK_AS_DEFAULT);
+ }
+
+ png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
+ }
+
+ void /* PRIVATE */
+-png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
++png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip)
+ {
+ png_ptr->process_mode = PNG_SKIP_MODE;
+ png_ptr->skip_length = skip;
+ }
+
+ void /* PRIVATE */
+-png_push_crc_finish(png_structp png_ptr)
++png_push_crc_finish(png_structrp png_ptr)
+ {
+- if (png_ptr->skip_length && png_ptr->save_buffer_size)
++ if (png_ptr->skip_length != 0 && png_ptr->save_buffer_size != 0)
+ {
+ png_size_t save_size = png_ptr->save_buffer_size;
+ png_uint_32 skip_length = png_ptr->skip_length;
+@@ -690,7 +501,7 @@
+ png_ptr->save_buffer_size -= save_size;
+ png_ptr->save_buffer_ptr += save_size;
+ }
+- if (png_ptr->skip_length && png_ptr->current_buffer_size)
++ if (png_ptr->skip_length != 0 && png_ptr->current_buffer_size != 0)
+ {
+ png_size_t save_size = png_ptr->current_buffer_size;
+ png_uint_32 skip_length = png_ptr->skip_length;
+@@ -711,14 +522,9 @@
+ png_ptr->current_buffer_size -= save_size;
+ png_ptr->current_buffer_ptr += save_size;
+ }
+- if (!png_ptr->skip_length)
++ if (png_ptr->skip_length == 0)
+ {
+- if (png_ptr->buffer_size < 4)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_LT(4)
+ png_crc_finish(png_ptr, 0);
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+ }
+@@ -733,7 +539,7 @@
+ return;
+
+ ptr = buffer;
+- if (png_ptr->save_buffer_size)
++ if (png_ptr->save_buffer_size != 0)
+ {
+ png_size_t save_size;
+
+@@ -743,14 +549,14 @@
+ else
+ save_size = png_ptr->save_buffer_size;
+
+- png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
++ memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
+ length -= save_size;
+ ptr += save_size;
+ png_ptr->buffer_size -= save_size;
+ png_ptr->save_buffer_size -= save_size;
+ png_ptr->save_buffer_ptr += save_size;
+ }
+- if (length && png_ptr->current_buffer_size)
++ if (length != 0 && png_ptr->current_buffer_size != 0)
+ {
+ png_size_t save_size;
+
+@@ -760,7 +566,7 @@
+ else
+ save_size = png_ptr->current_buffer_size;
+
+- png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
++ memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
+ png_ptr->buffer_size -= save_size;
+ png_ptr->current_buffer_size -= save_size;
+ png_ptr->current_buffer_ptr += save_size;
+@@ -768,9 +574,9 @@
+ }
+
+ void /* PRIVATE */
+-png_push_save_buffer(png_structp png_ptr)
++png_push_save_buffer(png_structrp png_ptr)
+ {
+- if (png_ptr->save_buffer_size)
++ if (png_ptr->save_buffer_size != 0)
+ {
+ if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
+ {
+@@ -806,16 +612,18 @@
+ if (png_ptr->save_buffer == NULL)
+ {
+ png_free(png_ptr, old_buffer);
++ old_buffer = NULL;
+ png_error(png_ptr, "Insufficient memory for save_buffer");
+ }
+
+- png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
++ memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
+ png_free(png_ptr, old_buffer);
++ old_buffer = NULL;
+ png_ptr->save_buffer_max = new_max;
+ }
+ if (png_ptr->current_buffer_size)
+ {
+- png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
++ memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
+ png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
+ png_ptr->save_buffer_size += png_ptr->current_buffer_size;
+ png_ptr->current_buffer_size = 0;
+@@ -825,7 +633,7 @@
+ }
+
+ void /* PRIVATE */
+-png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
++png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
+ png_size_t buffer_length)
+ {
+ png_ptr->current_buffer = buffer;
+@@ -835,30 +643,27 @@
+ }
+
+ void /* PRIVATE */
+-png_push_read_IDAT(png_structp png_ptr)
++png_push_read_IDAT(png_structrp png_ptr)
+ {
+- PNG_IDAT;
+- if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
++ if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
+ {
+ png_byte chunk_length[4];
++ png_byte chunk_tag[4];
+
+- if (png_ptr->buffer_size < 8)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ /* TODO: this code can be commoned up with the same code in push_read */
++ PNG_PUSH_SAVE_BUFFER_IF_LT(8)
+ png_push_fill_buffer(png_ptr, chunk_length, 4);
+ png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
+ png_reset_crc(png_ptr);
+- png_crc_read(png_ptr, png_ptr->chunk_name, 4);
++ png_crc_read(png_ptr, chunk_tag, 4);
++ png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
+ png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
+
+- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
++ if (png_ptr->chunk_name != png_IDAT)
+ {
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+
+- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
++ if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
+ png_error(png_ptr, "Not enough compressed data");
+
+ return;
+@@ -866,7 +671,8 @@
+
+ png_ptr->idat_size = png_ptr->push_length;
+ }
+- if (png_ptr->idat_size && png_ptr->save_buffer_size)
++
++ if (png_ptr->idat_size != 0 && png_ptr->save_buffer_size != 0)
+ {
+ png_size_t save_size = png_ptr->save_buffer_size;
+ png_uint_32 idat_size = png_ptr->idat_size;
+@@ -893,7 +699,7 @@
+ png_ptr->save_buffer_ptr += save_size;
+ }
+
+- if (png_ptr->idat_size && png_ptr->current_buffer_size)
++ if (png_ptr->idat_size != 0 && png_ptr->current_buffer_size != 0)
+ {
+ png_size_t save_size = png_ptr->current_buffer_size;
+ png_uint_32 idat_size = png_ptr->idat_size;
+@@ -918,22 +724,18 @@
+ png_ptr->current_buffer_size -= save_size;
+ png_ptr->current_buffer_ptr += save_size;
+ }
+- if (!png_ptr->idat_size)
++ if (png_ptr->idat_size == 0)
+ {
+- if (png_ptr->buffer_size < 4)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
++ PNG_PUSH_SAVE_BUFFER_IF_LT(4)
+ png_crc_finish(png_ptr, 0);
+ png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
+ png_ptr->mode |= PNG_AFTER_IDAT;
++ png_ptr->zowner = 0;
+ }
+ }
+
+ void /* PRIVATE */
+-png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
++png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
+ png_size_t buffer_length)
+ {
+ /* The caller checks for a non-zero buffer length. */
+@@ -945,13 +747,14 @@
+ * handle the uncompressed results.
+ */
+ png_ptr->zstream.next_in = buffer;
++ /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
+ png_ptr->zstream.avail_in = (uInt)buffer_length;
+
+ /* Keep going until the decompressed data is all processed
+ * or the stream marked as finished.
+ */
+ while (png_ptr->zstream.avail_in > 0 &&
+- !(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
++ !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
+ {
+ int ret;
+
+@@ -962,9 +765,9 @@
+ */
+ if (!(png_ptr->zstream.avail_out > 0))
+ {
+- png_ptr->zstream.avail_out =
+- (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,
+- png_ptr->iwidth) + 1;
++ /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
++ png_ptr->zstream.avail_out = (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
++ png_ptr->iwidth) + 1);
+
+ png_ptr->zstream.next_out = png_ptr->row_buf;
+ }
+@@ -982,7 +785,8 @@
+ if (ret != Z_OK && ret != Z_STREAM_END)
+ {
+ /* Terminate the decompression. */
+- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
++ png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
++ png_ptr->zowner = 0;
+
+ /* This may be a truncated stream (missing or
+ * damaged end code). Treat that as a warning.
+@@ -1010,7 +814,8 @@
+ {
+ /* Extra data. */
+ png_warning(png_ptr, "Extra compressed data in IDAT");
+- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
++ png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
++ png_ptr->zowner = 0;
+
+ /* Do no more processing; skip the unprocessed
+ * input check below.
+@@ -1025,7 +830,7 @@
+
+ /* And check for the end of the stream. */
+ if (ret == Z_STREAM_END)
+- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
++ png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
+ }
+
+ /* All the data should have been processed, if anything
+@@ -1037,41 +842,62 @@
+ }
+
+ void /* PRIVATE */
+-png_push_process_row(png_structp png_ptr)
++png_push_process_row(png_structrp png_ptr)
+ {
+- png_ptr->row_info.color_type = png_ptr->color_type;
+- png_ptr->row_info.width = png_ptr->iwidth;
+- png_ptr->row_info.channels = png_ptr->channels;
+- png_ptr->row_info.bit_depth = png_ptr->bit_depth;
+- png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
++ /* 1.5.6: row_info moved out of png_struct to a local here. */
++ png_row_info row_info;
+
+- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+- png_ptr->row_info.width);
++ row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
++ row_info.color_type = png_ptr->color_type;
++ row_info.bit_depth = png_ptr->bit_depth;
++ row_info.channels = png_ptr->channels;
++ row_info.pixel_depth = png_ptr->pixel_depth;
++ row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
+
+- png_read_filter_row(png_ptr, &(png_ptr->row_info),
+- png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+- (int)(png_ptr->row_buf[0]));
++ if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
++ {
++ if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
++ png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
++ png_ptr->prev_row + 1, png_ptr->row_buf[0]);
++ else
++ png_error(png_ptr, "bad adaptive filter value");
++ }
+
+- png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
++ /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
++ * 1.5.6, while the buffer really is this big in current versions of libpng
++ * it may not be in the future, so this was changed just to copy the
++ * interlaced row count:
++ */
++ memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
+
+ #ifdef PNG_READ_TRANSFORMS_SUPPORTED
+- if (png_ptr->transformations)
+- png_do_read_transformations(png_ptr);
++ if (png_ptr->transformations != 0)
++ png_do_read_transformations(png_ptr, &row_info);
+ #endif
+
++ /* The transformed pixel depth should match the depth now in row_info. */
++ if (png_ptr->transformed_pixel_depth == 0)
++ {
++ png_ptr->transformed_pixel_depth = row_info.pixel_depth;
++ if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
++ png_error(png_ptr, "progressive row overflow");
++ }
++
++ else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
++ png_error(png_ptr, "internal progressive row size calculation error");
++
++
+ #ifdef PNG_READ_INTERLACING_SUPPORTED
+- /* Blow up interlaced rows to full size */
+- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
++ /* Expand interlaced rows to full size */
++ if (png_ptr->interlaced != 0 &&
++ (png_ptr->transformations & PNG_INTERLACE) != 0)
+ {
+ if (png_ptr->pass < 6)
+-/* old interface (pre-1.0.9):
+- png_do_read_interlace(&(png_ptr->row_info),
+- png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+- */
+- png_do_read_interlace(png_ptr);
++ png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
++ png_ptr->transformations);
+
+- switch (png_ptr->pass)
+- {
++ switch (png_ptr->pass)
++ {
+ case 0:
+ {
+ int i;
+@@ -1238,7 +1064,6 @@
+ }
+ }
+ else
+-#endif
+ {
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);
+ png_read_push_finish_row(png_ptr);
+@@ -1246,36 +1071,36 @@
+ }
+
+ void /* PRIVATE */
+-png_read_push_finish_row(png_structp png_ptr)
++png_read_push_finish_row(png_structrp png_ptr)
+ {
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* Start of interlace block */
+- PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
++ static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* Offset to next interlace block */
+- PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* Start of interlace block in the y direction */
+- PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
++ static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* Offset to next interlace block in the y direction */
+- PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
++ static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
+
+ /* Height of interlace block. This is not currently used - if you need
+ * it, uncomment it here and in png.h
+- PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+ */
++#endif
+
+ png_ptr->row_number++;
+ if (png_ptr->row_number < png_ptr->num_rows)
+ return;
+
+-#ifdef PNG_READ_INTERLACING_SUPPORTED
+- if (png_ptr->interlaced)
++ if (png_ptr->interlaced != 0)
+ {
+ png_ptr->row_number = 0;
+- png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
++ memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+
+ do
+ {
+@@ -1296,7 +1121,7 @@
+ png_pass_start[png_ptr->pass]) /
+ png_pass_inc[png_ptr->pass];
+
+- if (png_ptr->transformations & PNG_INTERLACE)
++ if ((png_ptr->transformations & PNG_INTERLACE) != 0)
+ break;
+
+ png_ptr->num_rows = (png_ptr->height +
+@@ -1306,538 +1131,24 @@
+
+ } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
+ }
+-#endif /* PNG_READ_INTERLACING_SUPPORTED */
+-}
+-
+-#ifdef PNG_READ_tEXt_SUPPORTED
+-void /* PRIVATE */
+-png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+- length)
+-{
+- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+- {
+- PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */
+- png_error(png_ptr, "Out of place tEXt");
+- /* NOT REACHED */
+- }
+-
+-#ifdef PNG_MAX_MALLOC_64K
+- png_ptr->skip_length = 0; /* This may not be necessary */
+-
+- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
+- {
+- png_warning(png_ptr, "tEXt chunk too large to fit in memory");
+- png_ptr->skip_length = length - (png_uint_32)65535L;
+- length = (png_uint_32)65535L;
+- }
+-#endif
+-
+- png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+- (png_size_t)(length + 1));
+- png_ptr->current_text[length] = '\0';
+- png_ptr->current_text_ptr = png_ptr->current_text;
+- png_ptr->current_text_size = (png_size_t)length;
+- png_ptr->current_text_left = (png_size_t)length;
+- png_ptr->process_mode = PNG_READ_tEXt_MODE;
+ }
+
+ void /* PRIVATE */
+-png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
+-{
+- if (png_ptr->buffer_size && png_ptr->current_text_left)
+- {
+- png_size_t text_size;
+-
+- if (png_ptr->buffer_size < png_ptr->current_text_left)
+- text_size = png_ptr->buffer_size;
+-
+- else
+- text_size = png_ptr->current_text_left;
+-
+- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
+- png_ptr->current_text_left -= text_size;
+- png_ptr->current_text_ptr += text_size;
+- }
+- if (!(png_ptr->current_text_left))
+- {
+- png_textp text_ptr;
+- png_charp text;
+- png_charp key;
+- int ret;
+-
+- if (png_ptr->buffer_size < 4)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
+- png_push_crc_finish(png_ptr);
+-
+-#ifdef PNG_MAX_MALLOC_64K
+- if (png_ptr->skip_length)
+- return;
+-#endif
+-
+- key = png_ptr->current_text;
+-
+- for (text = key; *text; text++)
+- /* Empty loop */ ;
+-
+- if (text < key + png_ptr->current_text_size)
+- text++;
+-
+- text_ptr = (png_textp)png_malloc(png_ptr, png_sizeof(png_text));
+- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
+- text_ptr->key = key;
+- text_ptr->itxt_length = 0;
+- text_ptr->lang = NULL;
+- text_ptr->lang_key = NULL;
+- text_ptr->text = text;
+-
+- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+-
+- png_free(png_ptr, key);
+- png_free(png_ptr, text_ptr);
+- png_ptr->current_text = NULL;
+-
+- if (ret)
+- png_warning(png_ptr, "Insufficient memory to store text chunk");
+- }
+-}
+-#endif
+-
+-#ifdef PNG_READ_zTXt_SUPPORTED
+-void /* PRIVATE */
+-png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+- length)
+-{
+- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+- {
+- PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */
+- png_error(png_ptr, "Out of place zTXt");
+- /* NOT REACHED */
+- }
+-
+-#ifdef PNG_MAX_MALLOC_64K
+- /* We can't handle zTXt chunks > 64K, since we don't have enough space
+- * to be able to store the uncompressed data. Actually, the threshold
+- * is probably around 32K, but it isn't as definite as 64K is.
+- */
+- if (length > (png_uint_32)65535L)
+- {
+- png_warning(png_ptr, "zTXt chunk too large to fit in memory");
+- png_push_crc_skip(png_ptr, length);
+- return;
+- }
+-#endif
+-
+- png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+- (png_size_t)(length + 1));
+- png_ptr->current_text[length] = '\0';
+- png_ptr->current_text_ptr = png_ptr->current_text;
+- png_ptr->current_text_size = (png_size_t)length;
+- png_ptr->current_text_left = (png_size_t)length;
+- png_ptr->process_mode = PNG_READ_zTXt_MODE;
+-}
+-
+-void /* PRIVATE */
+-png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
+-{
+- if (png_ptr->buffer_size && png_ptr->current_text_left)
+- {
+- png_size_t text_size;
+-
+- if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
+- text_size = png_ptr->buffer_size;
+-
+- else
+- text_size = png_ptr->current_text_left;
+-
+- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
+- png_ptr->current_text_left -= text_size;
+- png_ptr->current_text_ptr += text_size;
+- }
+- if (!(png_ptr->current_text_left))
+- {
+- png_textp text_ptr;
+- png_charp text;
+- png_charp key;
+- int ret;
+- png_size_t text_size, key_size;
+-
+- if (png_ptr->buffer_size < 4)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
+- png_push_crc_finish(png_ptr);
+-
+- key = png_ptr->current_text;
+-
+- for (text = key; *text; text++)
+- /* Empty loop */ ;
+-
+- /* zTXt can't have zero text */
+- if (text >= key + png_ptr->current_text_size)
+- {
+- png_ptr->current_text = NULL;
+- png_free(png_ptr, key);
+- return;
+- }
+-
+- text++;
+-
+- if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */
+- {
+- png_ptr->current_text = NULL;
+- png_free(png_ptr, key);
+- return;
+- }
+-
+- text++;
+-
+- png_ptr->zstream.next_in = (png_bytep)text;
+- png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
+- (text - key));
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+-
+- key_size = text - key;
+- text_size = 0;
+- text = NULL;
+- ret = Z_STREAM_END;
+-
+- while (png_ptr->zstream.avail_in)
+- {
+- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+- if (ret != Z_OK && ret != Z_STREAM_END)
+- {
+- inflateReset(&png_ptr->zstream);
+- png_ptr->zstream.avail_in = 0;
+- png_ptr->current_text = NULL;
+- png_free(png_ptr, key);
+- png_free(png_ptr, text);
+- return;
+- }
+-
+- if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
+- {
+- if (text == NULL)
+- {
+- text = (png_charp)png_malloc(png_ptr,
+- (png_ptr->zbuf_size
+- - png_ptr->zstream.avail_out + key_size + 1));
+-
+- png_memcpy(text + key_size, png_ptr->zbuf,
+- png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+-
+- png_memcpy(text, key, key_size);
+-
+- text_size = key_size + png_ptr->zbuf_size -
+- png_ptr->zstream.avail_out;
+-
+- *(text + text_size) = '\0';
+- }
+-
+- else
+- {
+- png_charp tmp;
+-
+- tmp = text;
+- text = (png_charp)png_malloc(png_ptr, text_size +
+- (png_ptr->zbuf_size
+- - png_ptr->zstream.avail_out + 1));
+-
+- png_memcpy(text, tmp, text_size);
+- png_free(png_ptr, tmp);
+-
+- png_memcpy(text + text_size, png_ptr->zbuf,
+- png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+-
+- text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+- *(text + text_size) = '\0';
+- }
+-
+- if (ret != Z_STREAM_END)
+- {
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+- }
+- }
+- else
+- {
+- break;
+- }
+-
+- if (ret == Z_STREAM_END)
+- break;
+- }
+-
+- inflateReset(&png_ptr->zstream);
+- png_ptr->zstream.avail_in = 0;
+-
+- if (ret != Z_STREAM_END)
+- {
+- png_ptr->current_text = NULL;
+- png_free(png_ptr, key);
+- png_free(png_ptr, text);
+- return;
+- }
+-
+- png_ptr->current_text = NULL;
+- png_free(png_ptr, key);
+- key = text;
+- text += key_size;
+-
+- text_ptr = (png_textp)png_malloc(png_ptr,
+- png_sizeof(png_text));
+- text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
+- text_ptr->key = key;
+- text_ptr->itxt_length = 0;
+- text_ptr->lang = NULL;
+- text_ptr->lang_key = NULL;
+- text_ptr->text = text;
+-
+- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+-
+- png_free(png_ptr, key);
+- png_free(png_ptr, text_ptr);
+-
+- if (ret)
+- png_warning(png_ptr, "Insufficient memory to store text chunk");
+- }
+-}
+-#endif
+-
+-#ifdef PNG_READ_iTXt_SUPPORTED
+-void /* PRIVATE */
+-png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
+- length)
+-{
+- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
+- {
+- PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */
+- png_error(png_ptr, "Out of place iTXt");
+- /* NOT REACHED */
+- }
+-
+-#ifdef PNG_MAX_MALLOC_64K
+- png_ptr->skip_length = 0; /* This may not be necessary */
+-
+- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
+- {
+- png_warning(png_ptr, "iTXt chunk too large to fit in memory");
+- png_ptr->skip_length = length - (png_uint_32)65535L;
+- length = (png_uint_32)65535L;
+- }
+-#endif
+-
+- png_ptr->current_text = (png_charp)png_malloc(png_ptr,
+- (png_size_t)(length + 1));
+- png_ptr->current_text[length] = '\0';
+- png_ptr->current_text_ptr = png_ptr->current_text;
+- png_ptr->current_text_size = (png_size_t)length;
+- png_ptr->current_text_left = (png_size_t)length;
+- png_ptr->process_mode = PNG_READ_iTXt_MODE;
+-}
+-
+-void /* PRIVATE */
+-png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
+-{
+-
+- if (png_ptr->buffer_size && png_ptr->current_text_left)
+- {
+- png_size_t text_size;
+-
+- if (png_ptr->buffer_size < png_ptr->current_text_left)
+- text_size = png_ptr->buffer_size;
+-
+- else
+- text_size = png_ptr->current_text_left;
+-
+- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
+- png_ptr->current_text_left -= text_size;
+- png_ptr->current_text_ptr += text_size;
+- }
+-
+- if (!(png_ptr->current_text_left))
+- {
+- png_textp text_ptr;
+- png_charp key;
+- int comp_flag;
+- png_charp lang;
+- png_charp lang_key;
+- png_charp text;
+- int ret;
+-
+- if (png_ptr->buffer_size < 4)
+- {
+- png_push_save_buffer(png_ptr);
+- return;
+- }
+-
+- png_push_crc_finish(png_ptr);
+-
+-#ifdef PNG_MAX_MALLOC_64K
+- if (png_ptr->skip_length)
+- return;
+-#endif
+-
+- key = png_ptr->current_text;
+-
+- for (lang = key; *lang; lang++)
+- /* Empty loop */ ;
+-
+- if (lang < key + png_ptr->current_text_size - 3)
+- lang++;
+-
+- comp_flag = *lang++;
+- lang++; /* Skip comp_type, always zero */
+-
+- for (lang_key = lang; *lang_key; lang_key++)
+- /* Empty loop */ ;
+-
+- lang_key++; /* Skip NUL separator */
+-
+- text=lang_key;
+-
+- if (lang_key < key + png_ptr->current_text_size - 1)
+- {
+- for (; *text; text++)
+- /* Empty loop */ ;
+- }
+-
+- if (text < key + png_ptr->current_text_size)
+- text++;
+-
+- text_ptr = (png_textp)png_malloc(png_ptr,
+- png_sizeof(png_text));
+-
+- text_ptr->compression = comp_flag + 2;
+- text_ptr->key = key;
+- text_ptr->lang = lang;
+- text_ptr->lang_key = lang_key;
+- text_ptr->text = text;
+- text_ptr->text_length = 0;
+- text_ptr->itxt_length = png_strlen(text);
+-
+- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+-
+- png_ptr->current_text = NULL;
+-
+- png_free(png_ptr, text_ptr);
+- if (ret)
+- png_warning(png_ptr, "Insufficient memory to store iTXt chunk");
+- }
+-}
+-#endif
+-
+-/* This function is called when we haven't found a handler for this
+- * chunk. If there isn't a problem with the chunk itself (ie a bad chunk
+- * name or a critical chunk), the chunk is (currently) silently ignored.
+- */
+-void /* PRIVATE */
+-png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
+- length)
+-{
+- png_uint_32 skip = 0;
+-
+- if (!(png_ptr->chunk_name[0] & 0x20))
+- {
+-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+- if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+- PNG_HANDLE_CHUNK_ALWAYS
+-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+- && png_ptr->read_user_chunk_fn == NULL
+-#endif
+- )
+-#endif
+- png_chunk_error(png_ptr, "unknown critical chunk");
+-
+- PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */
+- }
+-
+-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+- if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
+- {
+-#ifdef PNG_MAX_MALLOC_64K
+- if (length > (png_uint_32)65535L)
+- {
+- png_warning(png_ptr, "unknown chunk too large to fit in memory");
+- skip = length - (png_uint_32)65535L;
+- length = (png_uint_32)65535L;
+- }
+-#endif
+- png_memcpy((png_charp)png_ptr->unknown_chunk.name,
+- (png_charp)png_ptr->chunk_name,
+- png_sizeof(png_ptr->unknown_chunk.name));
+- png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]
+- = '\0';
+-
+- png_ptr->unknown_chunk.size = (png_size_t)length;
+-
+- if (length == 0)
+- png_ptr->unknown_chunk.data = NULL;
+-
+- else
+- {
+- png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
+- (png_size_t)length);
+- png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
+- }
+-
+-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+- if (png_ptr->read_user_chunk_fn != NULL)
+- {
+- /* Callback to user unknown chunk handler */
+- int ret;
+- ret = (*(png_ptr->read_user_chunk_fn))
+- (png_ptr, &png_ptr->unknown_chunk);
+-
+- if (ret < 0)
+- png_chunk_error(png_ptr, "error in user chunk");
+-
+- if (ret == 0)
+- {
+- if (!(png_ptr->chunk_name[0] & 0x20))
+- if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+- PNG_HANDLE_CHUNK_ALWAYS)
+- png_chunk_error(png_ptr, "unknown critical chunk");
+- png_set_unknown_chunks(png_ptr, info_ptr,
+- &png_ptr->unknown_chunk, 1);
+- }
+- }
+-
+- else
+-#endif
+- png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
+- png_free(png_ptr, png_ptr->unknown_chunk.data);
+- png_ptr->unknown_chunk.data = NULL;
+- }
+-
+- else
+-#endif
+- skip=length;
+- png_push_crc_skip(png_ptr, skip);
+-}
+-
+-void /* PRIVATE */
+-png_push_have_info(png_structp png_ptr, png_infop info_ptr)
++png_push_have_info(png_structrp png_ptr, png_inforp info_ptr)
+ {
+ if (png_ptr->info_fn != NULL)
+ (*(png_ptr->info_fn))(png_ptr, info_ptr);
+ }
+
+ void /* PRIVATE */
+-png_push_have_end(png_structp png_ptr, png_infop info_ptr)
++png_push_have_end(png_structrp png_ptr, png_inforp info_ptr)
+ {
+ if (png_ptr->end_fn != NULL)
+ (*(png_ptr->end_fn))(png_ptr, info_ptr);
+ }
+
+ void /* PRIVATE */
+-png_push_have_row(png_structp png_ptr, png_bytep row)
++png_push_have_row(png_structrp png_ptr, png_bytep row)
+ {
+ if (png_ptr->row_fn != NULL)
+ (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
+@@ -1845,21 +1156,22 @@
+ }
+
+ void PNGAPI
+-png_progressive_combine_row (png_structp png_ptr, png_bytep old_row,
++png_progressive_combine_row(png_const_structrp png_ptr, png_bytep old_row,
+ png_const_bytep new_row)
+ {
+- PNG_CONST int FARDATA png_pass_dsp_mask[7] =
+- {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
+-
+ if (png_ptr == NULL)
+ return;
+
+- if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
+- png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
++ /* new_row is a flag here - if it is NULL then the app callback was called
++ * from an empty row (see the calls to png_struct::row_fn below), otherwise
++ * it must be png_ptr->row_buf+1
++ */
++ if (new_row != NULL)
++ png_combine_row(png_ptr, old_row, 1/*blocky display*/);
+ }
+
+ void PNGAPI
+-png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
++png_set_progressive_read_fn(png_structrp png_ptr, png_voidp progressive_ptr,
+ png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
+ png_progressive_end_ptr end_fn)
+ {
+@@ -1874,11 +1186,11 @@
+ }
+
+ png_voidp PNGAPI
+-png_get_progressive_ptr(png_const_structp png_ptr)
++png_get_progressive_ptr(png_const_structrp png_ptr)
+ {
+ if (png_ptr == NULL)
+ return (NULL);
+
+ return png_ptr->io_ptr;
+ }
+-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
++#endif /* PROGRESSIVE_READ */
+--- ./jdk/src/share/native/sun/awt/libpng/pngpriv.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngpriv.h Thu Feb 05 13:00:26 2015 +0100
+@@ -30,11 +30,11 @@
+ * file and, per its terms, should not be removed:
+ *
+ * For conditions of distribution and use, see copyright notice in png.h
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Copyright (c) 1998-2014 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.)
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
++ * Last changed in libpng 1.6.10 [March 6, 1014]]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+@@ -42,7 +42,7 @@
+ */
+
+ /* The symbols declared in this file (including the functions declared
+- * as PNG_EXTERN) are PRIVATE. They are not part of the libpng public
++ * as extern) are PRIVATE. They are not part of the libpng public
+ * interface, and are not recommended for use by regular applications.
+ * Some of them may become public in the future; others may stay private,
+ * change in an incompatible way, or even disappear.
+@@ -67,12 +67,44 @@
+ */
+ #define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */
+
+-/* This is required for the definition of abort(), used as a last ditch
+- * error handler when all else fails.
++#ifndef PNG_VERSION_INFO_ONLY
++/* Standard library headers not required by png.h: */
++# include <stdlib.h>
++# include <string.h>
++#endif
++
++#define PNGLIB_BUILD /*libpng is being built, not used*/
++
++/* If HAVE_CONFIG_H is defined during the build then the build system must
++ * provide an appropriate "config.h" file on the include path. The header file
++ * must provide definitions as required below (search for "HAVE_CONFIG_H");
++ * see configure.ac for more details of the requirements. The macro
++ * "PNG_NO_CONFIG_H" is provided for maintainers to test for dependencies on
++ * 'configure'; define this macro to prevent the configure build including the
++ * configure generated config.h. Libpng is expected to compile without *any*
++ * special build system support on a reasonably ANSI-C compliant system.
+ */
+-#include <stdlib.h>
++#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
++# include <config.h>
+
+-#define PNGLIB_BUILD
++ /* Pick up the definition of 'restrict' from config.h if it was read: */
++# define PNG_RESTRICT restrict
++#endif
++
++/* To support symbol prefixing it is necessary to know *before* including png.h
++ * whether the fixed point (and maybe other) APIs are exported, because if they
++ * are not internal definitions may be required. This is handled below just
++ * before png.h is included, but load the configuration now if it is available.
++ */
++#ifndef PNGLCONF_H
++# include "pnglibconf.h"
++#endif
++
++/* Local renames may change non-exported API functions from png.h */
++#if defined(PNG_PREFIX) && !defined(PNGPREFIX_H)
++# include "pngprefix.h"
++#endif
++
+ #ifdef PNG_USER_CONFIG
+ # include "pngusr.h"
+ /* These should have been defined in pngusr.h */
+@@ -83,25 +115,253 @@
+ # define PNG_USER_DLLFNAME_POSTFIX "Cb"
+ # endif
+ #endif
++
++/* Compile time options.
++ * =====================
++ * In a multi-arch build the compiler may compile the code several times for the
++ * same object module, producing different binaries for different architectures.
++ * When this happens configure-time setting of the target host options cannot be
++ * done and this interferes with the handling of the ARM NEON optimizations, and
++ * possibly other similar optimizations. Put additional tests here; in general
++ * this is needed when the same option can be changed at both compile time and
++ * run time depending on the target OS (i.e. iOS vs Android.)
++ *
++ * NOTE: symbol prefixing does not pass $(CFLAGS) to the preprocessor, because
++ * this is not possible with certain compilers (Oracle SUN OS CC), as a result
++ * it is necessary to ensure that all extern functions that *might* be used
++ * regardless of $(CFLAGS) get declared in this file. The test on __ARM_NEON__
++ * below is one example of this behavior because it is controlled by the
++ * presence or not of -mfpu=neon on the GCC command line, it is possible to do
++ * this in $(CC), e.g. "CC=gcc -mfpu=neon", but people who build libpng rarely
++ * do this.
++ */
++#ifndef PNG_ARM_NEON_OPT
++ /* ARM NEON optimizations are being controlled by the compiler settings,
++ * typically the target FPU. If the FPU has been set to NEON (-mfpu=neon
++ * with GCC) then the compiler will define __ARM_NEON__ and we can rely
++ * unconditionally on NEON instructions not crashing, otherwise we must
++ * disable use of NEON instructions.
++ *
++ * NOTE: at present these optimizations depend on 'ALIGNED_MEMORY', so they
++ * can only be turned on automatically if that is supported too. If
++ * PNG_ARM_NEON_OPT is set in CPPFLAGS (to >0) then arm/arm_init.c will fail
++ * to compile with an appropriate #error if ALIGNED_MEMORY has been turned
++ * off.
++ *
++ * Note that gcc-4.9 defines __ARM_NEON instead of __ARM_NEON__, so we
++ * check both variants.
++ */
++# if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && \
++ defined(PNG_ALIGNED_MEMORY_SUPPORTED)
++# define PNG_ARM_NEON_OPT 2
++# else
++# define PNG_ARM_NEON_OPT 0
++# endif
++#endif
++
++#if PNG_ARM_NEON_OPT > 0
++ /* NEON optimizations are to be at least considered by libpng, so enable the
++ * callbacks to do this.
++ */
++# define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon
++
++ /* By default the 'intrinsics' code in arm/filter_neon_intrinsics.c is used
++ * if possible - if __ARM_NEON__ is set and the compiler version is not known
++ * to be broken. This is controlled by PNG_ARM_NEON_IMPLEMENTATION which can
++ * be:
++ *
++ * 1 The intrinsics code (the default with __ARM_NEON__)
++ * 2 The hand coded assembler (the default without __ARM_NEON__)
++ *
++ * It is possible to set PNG_ARM_NEON_IMPLEMENTATION in CPPFLAGS, however
++ * this is *NOT* supported and may cease to work even after a minor revision
++ * to libpng. It *is* valid to do this for testing purposes, e.g. speed
++ * testing or a new compiler, but the results should be communicated to the
++ * libpng implementation list for incorporation in the next minor release.
++ */
++# ifndef PNG_ARM_NEON_IMPLEMENTATION
++# if defined(__ARM_NEON__) || defined(__ARM_NEON)
++# if defined(__clang__)
++ /* At present it is unknown by the libpng developers which versions
++ * of clang support the intrinsics, however some or perhaps all
++ * versions do not work with the assembler so this may be
++ * irrelevant, so just use the default (do nothing here.)
++ */
++# elif defined(__GNUC__)
++ /* GCC 4.5.4 NEON support is known to be broken. 4.6.3 is known to
++ * work, so if this *is* GCC, or G++, look for a version >4.5
++ */
++# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)
++# define PNG_ARM_NEON_IMPLEMENTATION 2
++# endif /* no GNUC support */
++# endif /* __GNUC__ */
++# else /* !defined __ARM_NEON__ */
++ /* The 'intrinsics' code simply won't compile without this -mfpu=neon:
++ */
++# define PNG_ARM_NEON_IMPLEMENTATION 2
++# endif /* __ARM_NEON__ */
++# endif /* !PNG_ARM_NEON_IMPLEMENTATION */
++
++# ifndef PNG_ARM_NEON_IMPLEMENTATION
++ /* Use the intrinsics code by default. */
++# define PNG_ARM_NEON_IMPLEMENTATION 1
++# endif
++#endif /* PNG_ARM_NEON_OPT > 0 */
++
++/* Is this a build of a DLL where compilation of the object modules requires
++ * different preprocessor settings to those required for a simple library? If
++ * so PNG_BUILD_DLL must be set.
++ *
++ * If libpng is used inside a DLL but that DLL does not export the libpng APIs
++ * PNG_BUILD_DLL must not be set. To avoid the code below kicking in build a
++ * static library of libpng then link the DLL against that.
++ */
++#ifndef PNG_BUILD_DLL
++# ifdef DLL_EXPORT
++ /* This is set by libtool when files are compiled for a DLL; libtool
++ * always compiles twice, even on systems where it isn't necessary. Set
++ * PNG_BUILD_DLL in case it is necessary:
++ */
++# define PNG_BUILD_DLL
++# else
++# ifdef _WINDLL
++ /* This is set by the Microsoft Visual Studio IDE in projects that
++ * build a DLL. It can't easily be removed from those projects (it
++ * isn't visible in the Visual Studio UI) so it is a fairly reliable
++ * indication that PNG_IMPEXP needs to be set to the DLL export
++ * attributes.
++ */
++# define PNG_BUILD_DLL
++# else
++# ifdef __DLL__
++ /* This is set by the Borland C system when compiling for a DLL
++ * (as above.)
++ */
++# define PNG_BUILD_DLL
++# else
++ /* Add additional compiler cases here. */
++# endif
++# endif
++# endif
++#endif /* Setting PNG_BUILD_DLL if required */
++
++/* See pngconf.h for more details: the builder of the library may set this on
++ * the command line to the right thing for the specific compilation system or it
++ * may be automagically set above (at present we know of no system where it does
++ * need to be set on the command line.)
++ *
++ * PNG_IMPEXP must be set here when building the library to prevent pngconf.h
++ * setting it to the "import" setting for a DLL build.
++ */
++#ifndef PNG_IMPEXP
++# ifdef PNG_BUILD_DLL
++# define PNG_IMPEXP PNG_DLL_EXPORT
++# else
++ /* Not building a DLL, or the DLL doesn't require specific export
++ * definitions.
++ */
++# define PNG_IMPEXP
++# endif
++#endif
++
++/* No warnings for private or deprecated functions in the build: */
++#ifndef PNG_DEPRECATED
++# define PNG_DEPRECATED
++#endif
++#ifndef PNG_PRIVATE
++# define PNG_PRIVATE
++#endif
++
++/* Symbol preprocessing support.
++ *
++ * To enable listing global, but internal, symbols the following macros should
++ * always be used to declare an extern data or function object in this file.
++ */
++#ifndef PNG_INTERNAL_DATA
++# define PNG_INTERNAL_DATA(type, name, array) extern type name array
++#endif
++
++#ifndef PNG_INTERNAL_FUNCTION
++# define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\
++ extern PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)
++#endif
++
++#ifndef PNG_INTERNAL_CALLBACK
++# define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\
++ extern PNG_FUNCTION(type, (PNGCBAPI name), args, PNG_EMPTY attributes)
++#endif
++
++/* If floating or fixed point APIs are disabled they may still be compiled
++ * internally. To handle this make sure they are declared as the appropriate
++ * internal extern function (otherwise the symbol prefixing stuff won't work and
++ * the functions will be used without definitions.)
++ *
++ * NOTE: although all the API functions are declared here they are not all
++ * actually built! Because the declarations are still made it is necessary to
++ * fake out types that they depend on.
++ */
++#ifndef PNG_FP_EXPORT
++# ifndef PNG_FLOATING_POINT_SUPPORTED
++# define PNG_FP_EXPORT(ordinal, type, name, args)\
++ PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
++# ifndef PNG_VERSION_INFO_ONLY
++ typedef struct png_incomplete png_double;
++ typedef png_double* png_doublep;
++ typedef const png_double* png_const_doublep;
++ typedef png_double** png_doublepp;
++# endif
++# endif
++#endif
++#ifndef PNG_FIXED_EXPORT
++# ifndef PNG_FIXED_POINT_SUPPORTED
++# define PNG_FIXED_EXPORT(ordinal, type, name, args)\
++ PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
++# endif
++#endif
++
+ #include "png.h"
+-#include "pnginfo.h"
+-#include "pngstruct.h"
+
+-/* This is used for 16 bit gamma tables - only the top level pointers are const,
+- * this could be changed:
++/* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */
++#ifndef PNG_DLL_EXPORT
++# define PNG_DLL_EXPORT
++#endif
++
++/* SECURITY and SAFETY:
++ *
++ * By default libpng is built without any internal limits on image size,
++ * individual heap (png_malloc) allocations or the total amount of memory used.
++ * If PNG_SAFE_LIMITS_SUPPORTED is defined, however, the limits below are used
++ * (unless individually overridden). These limits are believed to be fairly
++ * safe, but builders of secure systems should verify the values against the
++ * real system capabilities.
+ */
+-typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp;
+-
+-/* Added at libpng-1.2.9 */
+-/* Moved to pngpriv.h at libpng-1.5.0 */
+-
+-/* config.h is created by and PNG_CONFIGURE_LIBPNG is set by the "configure"
+- * script. We may need it here to get the correct configuration on things
+- * like limits.
+- */
+-#ifdef PNG_CONFIGURE_LIBPNG
+-# ifdef HAVE_CONFIG_H
+-# include "config.h"
++#ifdef PNG_SAFE_LIMITS_SUPPORTED
++ /* 'safe' limits */
++# ifndef PNG_USER_WIDTH_MAX
++# define PNG_USER_WIDTH_MAX 1000000
++# endif
++# ifndef PNG_USER_HEIGHT_MAX
++# define PNG_USER_HEIGHT_MAX 1000000
++# endif
++# ifndef PNG_USER_CHUNK_CACHE_MAX
++# define PNG_USER_CHUNK_CACHE_MAX 128
++# endif
++# ifndef PNG_USER_CHUNK_MALLOC_MAX
++# define PNG_USER_CHUNK_MALLOC_MAX 8000000
++# endif
++#else
++ /* values for no limits */
++# ifndef PNG_USER_WIDTH_MAX
++# define PNG_USER_WIDTH_MAX 0x7fffffff
++# endif
++# ifndef PNG_USER_HEIGHT_MAX
++# define PNG_USER_HEIGHT_MAX 0x7fffffff
++# endif
++# ifndef PNG_USER_CHUNK_CACHE_MAX
++# define PNG_USER_CHUNK_CACHE_MAX 0
++# endif
++# ifndef PNG_USER_CHUNK_MALLOC_MAX
++# define PNG_USER_CHUNK_MALLOC_MAX 0
+ # endif
+ #endif
+
+@@ -143,13 +403,6 @@
+ # define PNG_ZBUF_SIZE 65536L
+ #endif
+
+-/* PNG_STATIC is used to mark internal file scope functions if they need to be
+- * accessed for implementation tests (see the code in tests/?*).
+- */
+-#ifndef PNG_STATIC
+-# define PNG_STATIC static
+-#endif
+-
+ /* If warnings or errors are turned off the code is disabled or redirected here.
+ * From 1.5.4 functions have been added to allow very limited formatting of
+ * error and warning messages - this code will also be disabled here.
+@@ -157,8 +410,6 @@
+ #ifdef PNG_WARNINGS_SUPPORTED
+ # define PNG_WARNING_PARAMETERS(p) png_warning_parameters p;
+ #else
+-# define png_warning(s1,s2) ((void)(s1))
+-# define png_chunk_warning(s1,s2) ((void)(s1))
+ # define png_warning_parameter(p,number,string) ((void)0)
+ # define png_warning_parameter_unsigned(p,number,format,value) ((void)0)
+ # define png_warning_parameter_signed(p,number,format,value) ((void)0)
+@@ -166,21 +417,27 @@
+ # define PNG_WARNING_PARAMETERS(p)
+ #endif
+ #ifndef PNG_ERROR_TEXT_SUPPORTED
+-# define png_error(s1,s2) png_err(s1)
+-# define png_chunk_error(s1,s2) png_err(s1)
+ # define png_fixed_error(s1,s2) png_err(s1)
+ #endif
+
+-#ifndef PNG_EXTERN
+-/* The functions exported by PNG_EXTERN are internal functions, which
+- * aren't usually used outside the library (as far as I know), so it is
+- * debatable if they should be exported at all. In the future, when it
+- * is possible to have run-time registry of chunk-handling functions,
+- * some of these might be made available again.
+-# define PNG_EXTERN extern
++/* C allows up-casts from (void*) to any pointer and (const void*) to any
++ * pointer to a const object. C++ regards this as a type error and requires an
++ * explicit, static, cast and provides the static_cast<> rune to ensure that
++ * const is not cast away.
+ */
+-# define PNG_EXTERN
+-#endif
++#ifdef __cplusplus
++# define png_voidcast(type, value) static_cast<type>(value)
++# define png_constcast(type, value) const_cast<type>(value)
++# define png_aligncast(type, value) \
++ static_cast<type>(static_cast<void*>(value))
++# define png_aligncastconst(type, value) \
++ static_cast<type>(static_cast<const void*>(value))
++#else
++# define png_voidcast(type, value) (value)
++# define png_constcast(type, value) ((type)(value))
++# define png_aligncast(type, value) ((void*)(value))
++# define png_aligncastconst(type, value) ((const void*)(value))
++#endif /* __cplusplus */
+
+ /* Some fixed point APIs are still required even if not exported because
+ * they get used by the corresponding floating point APIs. This magic
+@@ -192,6 +449,7 @@
+ # define PNGFAPI /* PRIVATE */
+ #endif
+
++#ifndef PNG_VERSION_INFO_ONLY
+ /* Other defines specific to compilers can go here. Try to keep
+ * them inside an appropriate ifdef/endif pair for portability.
+ */
+@@ -236,6 +494,7 @@
+ defined(_WIN32) || defined(__WIN32__)
+ # include <windows.h> /* defines _WINDOWS_ macro */
+ #endif
++#endif /* PNG_VERSION_INFO_ONLY */
+
+ /* Moved here around 1.5.0beta36 from pngconf.h */
+ /* Users may want to use these so they are not private. Any library
+@@ -251,33 +510,51 @@
+ # endif
+ #endif
+
+-#ifdef USE_FAR_KEYWORD
+-/* Use this to make far-to-near assignments */
+-# define CHECK 1
+-# define NOCHECK 0
+-# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))
+-# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))
+-# define png_strlen _fstrlen
+-# define png_memcmp _fmemcmp /* SJT: added */
+-# define png_memcpy _fmemcpy
+-# define png_memset _fmemset
++/* These macros may need to be architecture dependent. */
++#define PNG_ALIGN_NONE 0 /* do not use data alignment */
++#define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */
++#ifdef offsetof
++# define PNG_ALIGN_OFFSET 2 /* use offsetof to determine alignment */
+ #else
+-# ifdef _WINDOWS_ /* Favor Windows over C runtime fns */
+-# define CVT_PTR(ptr) (ptr)
+-# define CVT_PTR_NOCHECK(ptr) (ptr)
+-# define png_strlen lstrlenA
+-# define png_memcmp memcmp
+-# define png_memcpy CopyMemory
+-# define png_memset memset
++# define PNG_ALIGN_OFFSET -1 /* prevent the use of this */
++#endif
++#define PNG_ALIGN_SIZE 3 /* use sizeof to determine alignment */
++
++#ifndef PNG_ALIGN_TYPE
++ /* Default to using aligned access optimizations and requiring alignment to a
++ * multiple of the data type size. Override in a compiler specific fashion
++ * if necessary by inserting tests here:
++ */
++# define PNG_ALIGN_TYPE PNG_ALIGN_SIZE
++#endif
++
++#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_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.
++ */
++# define png_alignof(type) (sizeof (type))
++#else
++# if PNG_ALIGN_TYPE == PNG_ALIGN_OFFSET
++# define png_alignof(type) offsetof(struct{char c; type t;}, t)
+ # else
+-# define CVT_PTR(ptr) (ptr)
+-# define CVT_PTR_NOCHECK(ptr) (ptr)
+-# define png_strlen strlen
+-# define png_memcmp memcmp /* SJT: added */
+-# define png_memcpy memcpy
+-# define png_memset memset
++# if PNG_ALIGN_TYPE == PNG_ALIGN_ALWAYS
++# define png_alignof(type) (1)
++# endif
++ /* Else leave png_alignof undefined to prevent use thereof */
+ # endif
+ #endif
++
++/* This implicitly assumes alignment is always to a power of 2. */
++#ifdef png_alignof
++# define png_isaligned(ptr, type)\
++ ((((const char*)ptr-(const char*)0) & (png_alignof(type)-1)) == 0)
++#else
++# define png_isaligned(ptr, type) 0
++#endif
++
+ /* End of memory model/platform independent support */
+ /* End of 1.5.0beta36 move from pngconf.h */
+
+@@ -295,15 +572,17 @@
+ #define PNG_HAVE_IDAT 0x04
+ /* #define PNG_AFTER_IDAT 0x08 (defined in png.h) */
+ #define PNG_HAVE_IEND 0x10
+-#define PNG_HAVE_gAMA 0x20
+-#define PNG_HAVE_cHRM 0x40
+-#define PNG_HAVE_sRGB 0x80
++ /* 0x20 (unused) */
++ /* 0x40 (unused) */
++ /* 0x80 (unused) */
+ #define PNG_HAVE_CHUNK_HEADER 0x100
+ #define PNG_WROTE_tIME 0x200
+ #define PNG_WROTE_INFO_BEFORE_PLTE 0x400
+ #define PNG_BACKGROUND_IS_GRAY 0x800
+ #define PNG_HAVE_PNG_SIGNATURE 0x1000
+ #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
++ /* 0x4000 (unused) */
++#define PNG_IS_READ_STRUCT 0x8000 /* Else is a write struct */
+
+ /* Flags for the transformations the PNG library does on the image data */
+ #define PNG_BGR 0x0001
+@@ -321,24 +600,23 @@
+ #define PNG_EXPAND 0x1000
+ #define PNG_GAMMA 0x2000
+ #define PNG_GRAY_TO_RGB 0x4000
+-#define PNG_FILLER 0x8000L
+-#define PNG_PACKSWAP 0x10000L
+-#define PNG_SWAP_ALPHA 0x20000L
+-#define PNG_STRIP_ALPHA 0x40000L
+-#define PNG_INVERT_ALPHA 0x80000L
+-#define PNG_USER_TRANSFORM 0x100000L
+-#define PNG_RGB_TO_GRAY_ERR 0x200000L
+-#define PNG_RGB_TO_GRAY_WARN 0x400000L
+-#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */
+-#define PNG_ENCODE_ALPHA 0x800000L /* Added to libpng-1.5.4 */
+-#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */
+-#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */
+-#define PNG_SCALE_16_TO_8 0x4000000L /* Added to libpng-1.5.4 */
+- /* 0x8000000L unused */
+- /* 0x10000000L unused */
+- /* 0x20000000L unused */
+- /* 0x40000000L unused */
+-
++#define PNG_FILLER 0x8000
++#define PNG_PACKSWAP 0x10000
++#define PNG_SWAP_ALPHA 0x20000
++#define PNG_STRIP_ALPHA 0x40000
++#define PNG_INVERT_ALPHA 0x80000
++#define PNG_USER_TRANSFORM 0x100000
++#define PNG_RGB_TO_GRAY_ERR 0x200000
++#define PNG_RGB_TO_GRAY_WARN 0x400000
++#define PNG_RGB_TO_GRAY 0x600000 /* two bits, RGB_TO_GRAY_ERR|WARN */
++#define PNG_ENCODE_ALPHA 0x800000 /* Added to libpng-1.5.4 */
++#define PNG_ADD_ALPHA 0x1000000 /* Added to libpng-1.2.7 */
++#define PNG_EXPAND_tRNS 0x2000000 /* Added to libpng-1.2.9 */
++#define PNG_SCALE_16_TO_8 0x4000000 /* Added to libpng-1.5.4 */
++ /* 0x8000000 unused */
++ /* 0x10000000 unused */
++ /* 0x20000000 unused */
++ /* 0x40000000 unused */
+ /* Flags for png_create_struct */
+ #define PNG_STRUCT_PNG 0x0001
+ #define PNG_STRUCT_INFO 0x0002
+@@ -349,36 +627,36 @@
+
+ /* Flags for the png_ptr->flags rather than declaring a byte for each one */
+ #define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001
+-#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002
+-#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004
+-#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008
+-#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010
+-#define PNG_FLAG_ZLIB_FINISHED 0x0020
++#define PNG_FLAG_ZSTREAM_INITIALIZED 0x0002 /* Added to libpng-1.6.0 */
++ /* 0x0004 unused */
++#define PNG_FLAG_ZSTREAM_ENDED 0x0008 /* Added to libpng-1.6.0 */
++ /* 0x0010 unused */
++ /* 0x0020 unused */
+ #define PNG_FLAG_ROW_INIT 0x0040
+ #define PNG_FLAG_FILLER_AFTER 0x0080
+ #define PNG_FLAG_CRC_ANCILLARY_USE 0x0100
+ #define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200
+ #define PNG_FLAG_CRC_CRITICAL_USE 0x0400
+ #define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800
+-#define PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */
+-#define PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */
+-#define PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */
+-#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L
+-#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L
+-#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L
+-#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L
+-#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L
+-#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L
+- /* 0x200000L unused */
+- /* 0x400000L unused */
+-#define PNG_FLAG_BENIGN_ERRORS_WARN 0x800000L /* Added to libpng-1.4.0 */
+-#define PNG_FLAG_ZTXT_CUSTOM_STRATEGY 0x1000000L /* 5 lines added */
+-#define PNG_FLAG_ZTXT_CUSTOM_LEVEL 0x2000000L /* to libpng-1.5.4 */
+-#define PNG_FLAG_ZTXT_CUSTOM_MEM_LEVEL 0x4000000L
+-#define PNG_FLAG_ZTXT_CUSTOM_WINDOW_BITS 0x8000000L
+-#define PNG_FLAG_ZTXT_CUSTOM_METHOD 0x10000000L
+- /* 0x20000000L unused */
+- /* 0x40000000L unused */
++#define PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */
++#define PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */
++#define PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */
++/* #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000 */
++/* #define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000 */
++#define PNG_FLAG_LIBRARY_MISMATCH 0x20000
++#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000
++#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000
++#define PNG_FLAG_BENIGN_ERRORS_WARN 0x100000 /* Added to libpng-1.4.0 */
++#define PNG_FLAG_APP_WARNINGS_WARN 0x200000 /* Added to libpng-1.6.0 */
++#define PNG_FLAG_APP_ERRORS_WARN 0x400000 /* Added to libpng-1.6.0 */
++ /* 0x800000 unused */
++ /* 0x1000000 unused */
++ /* 0x2000000 unused */
++ /* 0x4000000 unused */
++ /* 0x8000000 unused */
++ /* 0x10000000 unused */
++ /* 0x20000000 unused */
++ /* 0x40000000 unused */
+
+ #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
+ PNG_FLAG_CRC_ANCILLARY_NOWARN)
+@@ -389,24 +667,23 @@
+ #define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \
+ PNG_FLAG_CRC_CRITICAL_MASK)
+
+-/* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib
+- * can handle at once. This type need be no larger than 16 bits (so maximum of
+- * 65535), this define allows us to discover how big it is, but limited by the
+- * maximuum for png_size_t. The value can be overriden in a library build
+- * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably
+- * lower value (e.g. 255 works). A lower value may help memory usage (slightly)
+- * and may even improve performance on some systems (and degrade it on others.)
+- */
+-#ifndef ZLIB_IO_MAX
+-# define ZLIB_IO_MAX ((uInt)-1)
+-#endif
+-
+ /* Save typing and make code easier to understand */
+
+ #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
+ abs((int)((c1).green) - (int)((c2).green)) + \
+ abs((int)((c1).blue) - (int)((c2).blue)))
+
++/* Added to libpng-1.6.0: scale a 16-bit value in the range 0..65535 to 0..255
++ * by dividing by 257 *with rounding*. This macro is exact for the given range.
++ * See the discourse in pngrtran.c png_do_scale_16_to_8. The values in the
++ * macro were established by experiment (modifying the added value). The macro
++ * has a second variant that takes a value already scaled by 255 and divides by
++ * 65535 - this has a maximum error of .502. Over the range 0..65535*65535 it
++ * only gives off-by-one errors and only for 0.5% (1 in 200) of the values.
++ */
++#define PNG_DIV65535(v24) (((v24) + 32895) >> 16)
++#define PNG_DIV257(v16) PNG_DIV65535((png_uint_32)(v16) * 255)
++
+ /* Added to libpng-1.2.6 JB */
+ #define PNG_ROWBYTES(pixel_bits, width) \
+ ((pixel_bits) >= 8 ? \
+@@ -454,151 +731,314 @@
+ #ifdef PNG_FIXED_POINT_MACRO_SUPPORTED
+ #define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\
+ ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))
+-#else
+-PNG_EXTERN png_fixed_point png_fixed PNGARG((png_structp png_ptr, double fp,
+- png_const_charp text));
+ #endif
++/* else the corresponding function is defined below, inside the scope of the
++ * cplusplus test.
++ */
+ #endif
+
+-/* Constant strings for known chunk types. If you need to add a chunk,
+- * define the name here, and add an invocation of the macro wherever it's
+- * needed.
++/* Constants for known chunk types. If you need to add a chunk, define the name
++ * here. For historical reasons these constants have the form png_<name>; i.e.
++ * the prefix is lower case. Please use decimal values as the parameters to
++ * match the ISO PNG specification and to avoid relying on the C locale
++ * interpretation of character values.
++ *
++ * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values
++ * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string
++ * to be generated if required.
++ *
++ * PNG_32b correctly produces a value shifted by up to 24 bits, even on
++ * architectures where (int) is only 16 bits.
+ */
+-#define PNG_IHDR PNG_CONST png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'}
+-#define PNG_IDAT PNG_CONST png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'}
+-#define PNG_IEND PNG_CONST png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'}
+-#define PNG_PLTE PNG_CONST png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'}
+-#define PNG_bKGD PNG_CONST png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'}
+-#define PNG_cHRM PNG_CONST png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'}
+-#define PNG_gAMA PNG_CONST png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'}
+-#define PNG_hIST PNG_CONST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'}
+-#define PNG_iCCP PNG_CONST png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'}
+-#define PNG_iTXt PNG_CONST png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'}
+-#define PNG_oFFs PNG_CONST png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'}
+-#define PNG_pCAL PNG_CONST png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'}
+-#define PNG_sCAL PNG_CONST png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'}
+-#define PNG_pHYs PNG_CONST png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'}
+-#define PNG_sBIT PNG_CONST png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'}
+-#define PNG_sPLT PNG_CONST png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'}
+-#define PNG_sRGB PNG_CONST png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'}
+-#define PNG_sTER PNG_CONST png_byte png_sTER[5] = {115, 84, 69, 82, '\0'}
+-#define PNG_tEXt PNG_CONST png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'}
+-#define PNG_tIME PNG_CONST png_byte png_tIME[5] = {116, 73, 77, 69, '\0'}
+-#define PNG_tRNS PNG_CONST png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'}
+-#define PNG_zTXt PNG_CONST png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'}
++#define PNG_32b(b,s) ((png_uint_32)(b) << (s))
++#define PNG_U32(b1,b2,b3,b4) \
++ (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
++
++/* Constants for known chunk types.
++ *
++ * MAINTAINERS: If you need to add a chunk, define the name here.
++ * For historical reasons these constants have the form png_<name>; i.e.
++ * the prefix is lower case. Please use decimal values as the parameters to
++ * match the ISO PNG specification and to avoid relying on the C locale
++ * interpretation of character values. Please keep the list sorted.
++ *
++ * Notice that PNG_U32 is used to define a 32-bit value for the 4 byte chunk
++ * type. In fact the specification does not express chunk types this way,
++ * however using a 32-bit value means that the chunk type can be read from the
++ * stream using exactly the same code as used for a 32-bit unsigned value and
++ * can be examined far more efficiently (using one arithmetic compare).
++ *
++ * Prior to 1.5.6 the chunk type constants were expressed as C strings. The
++ * libpng API still uses strings for 'unknown' chunks and a macro,
++ * PNG_STRING_FROM_CHUNK, allows a string to be generated if required. Notice
++ * that for portable code numeric values must still be used; the string "IHDR"
++ * is not portable and neither is PNG_U32('I', 'H', 'D', 'R').
++ *
++ * In 1.7.0 the definitions will be made public in png.h to avoid having to
++ * duplicate the same definitions in application code.
++ */
++#define png_IDAT PNG_U32( 73, 68, 65, 84)
++#define png_IEND PNG_U32( 73, 69, 78, 68)
++#define png_IHDR PNG_U32( 73, 72, 68, 82)
++#define png_PLTE PNG_U32( 80, 76, 84, 69)
++#define png_bKGD PNG_U32( 98, 75, 71, 68)
++#define png_cHRM PNG_U32( 99, 72, 82, 77)
++#define png_fRAc PNG_U32(102, 82, 65, 99) /* registered, not defined */
++#define png_gAMA PNG_U32(103, 65, 77, 65)
++#define png_gIFg PNG_U32(103, 73, 70, 103)
++#define png_gIFt PNG_U32(103, 73, 70, 116) /* deprecated */
++#define png_gIFx PNG_U32(103, 73, 70, 120)
++#define png_hIST PNG_U32(104, 73, 83, 84)
++#define png_iCCP PNG_U32(105, 67, 67, 80)
++#define png_iTXt PNG_U32(105, 84, 88, 116)
++#define png_oFFs PNG_U32(111, 70, 70, 115)
++#define png_pCAL PNG_U32(112, 67, 65, 76)
++#define png_pHYs PNG_U32(112, 72, 89, 115)
++#define png_sBIT PNG_U32(115, 66, 73, 84)
++#define png_sCAL PNG_U32(115, 67, 65, 76)
++#define png_sPLT PNG_U32(115, 80, 76, 84)
++#define png_sRGB PNG_U32(115, 82, 71, 66)
++#define png_sTER PNG_U32(115, 84, 69, 82)
++#define png_tEXt PNG_U32(116, 69, 88, 116)
++#define png_tIME PNG_U32(116, 73, 77, 69)
++#define png_tRNS PNG_U32(116, 82, 78, 83)
++#define png_zTXt PNG_U32(122, 84, 88, 116)
++
++/* The following will work on (signed char*) strings, whereas the get_uint_32
++ * macro will fail on top-bit-set values because of the sign extension.
++ */
++#define PNG_CHUNK_FROM_STRING(s)\
++ PNG_U32(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3])
++
++/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
++ * signed and the argument is a (char[]) This macro will fail miserably on
++ * systems where (char) is more than 8 bits.
++ */
++#define PNG_STRING_FROM_CHUNK(s,c)\
++ (void)(((char*)(s))[0]=(char)((c)>>24), ((char*)(s))[1]=(char)((c)>>16),\
++ ((char*)(s))[2]=(char)((c)>>8), ((char*)(s))[3]=(char)((c)))
++
++/* Do the same but terminate with a null character. */
++#define PNG_CSTRING_FROM_CHUNK(s,c)\
++ (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)
++
++/* Test on flag values as defined in the spec (section 5.4): */
++#define PNG_CHUNK_ANCILLARY(c) (1 & ((c) >> 29))
++#define PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLARY(c))
++#define PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21))
++#define PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13))
++#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5))
+
+ /* Gamma values (new at libpng-1.5.4): */
+ #define PNG_GAMMA_MAC_OLD 151724 /* Assume '1.8' is really 2.2/1.45! */
+ #define PNG_GAMMA_MAC_INVERSE 65909
+ #define PNG_GAMMA_sRGB_INVERSE 45455
+
++/* Almost everything below is C specific; the #defines above can be used in
++ * non-C code (so long as it is C-preprocessed) the rest of this stuff cannot.
++ */
++#ifndef PNG_VERSION_INFO_ONLY
++
++#include "pngstruct.h"
++#include "pnginfo.h"
++
++/* Validate the include paths - the include path used to generate pnglibconf.h
++ * must match that used in the build, or we must be using pnglibconf.h.prebuilt:
++ */
++#if PNG_ZLIB_VERNUM != 0 && PNG_ZLIB_VERNUM != ZLIB_VERNUM
++# error ZLIB_VERNUM != PNG_ZLIB_VERNUM \
++ "-I (include path) error: see the notes in pngpriv.h"
++ /* This means that when pnglibconf.h was built the copy of zlib.h that it
++ * used is not the same as the one being used here. Because the build of
++ * libpng makes decisions to use inflateInit2 and inflateReset2 based on the
++ * zlib version number and because this affects handling of certain broken
++ * PNG files the -I directives must match.
++ *
++ * The most likely explanation is that you passed a -I in CFLAGS. This will
++ * not work; all the preprocessor directories and in particular all the -I
++ * directives must be in CPPFLAGS.
++ */
++#endif
++
++/* This is used for 16 bit gamma tables -- only the top level pointers are
++ * const; this could be changed:
++ */
++typedef const png_uint_16p * png_const_uint_16pp;
++
++/* Added to libpng-1.5.7: sRGB conversion tables */
++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
++ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
++#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
++PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]);
++ /* Convert from an sRGB encoded value 0..255 to a 16-bit linear value,
++ * 0..65535. This table gives the closest 16-bit answers (no errors).
++ */
++#endif
++
++PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]);
++PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
++
++#define PNG_sRGB_FROM_LINEAR(linear) ((png_byte)((png_sRGB_base[(linear)>>15] +\
++ ((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8))
++ /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
++ * encoded value with maximum error 0.646365. Note that the input is not a
++ * 16-bit value; it has been multiplied by 255! */
++#endif /* SIMPLIFIED_READ/WRITE */
++
+
+ /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
+ #ifdef __cplusplus
+ extern "C" {
+ #endif /* __cplusplus */
+
+-/* These functions are used internally in the code. They generally
+- * shouldn't be used unless you are writing code to add or replace some
+- * functionality in libpng. More information about most functions can
+- * be found in the files where the functions are located.
++/* Internal functions; these are not exported from a DLL however because they
++ * are used within several of the C source files they have to be C extern.
++ *
++ * All of these functions must be declared with PNG_INTERNAL_FUNCTION.
+ */
+
++/* Zlib support */
++#define PNG_UNEXPECTED_ZLIB_RETURN (-7)
++PNG_INTERNAL_FUNCTION(void, png_zstream_error,(png_structrp png_ptr, int ret),
++ PNG_EMPTY);
++ /* Used by the zlib handling functions to ensure that z_stream::msg is always
++ * set before they return.
++ */
++
++#ifdef PNG_WRITE_SUPPORTED
++PNG_INTERNAL_FUNCTION(void,png_free_buffer_list,(png_structrp png_ptr,
++ png_compression_bufferp *list),PNG_EMPTY);
++ /* Free the buffer list used by the compressed write code. */
++#endif
++
++#if defined(PNG_FLOATING_POINT_SUPPORTED) && \
++ !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
++ (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
++ defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
++ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
++ (defined(PNG_sCAL_SUPPORTED) && \
++ defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
++PNG_INTERNAL_FUNCTION(png_fixed_point,png_fixed,(png_const_structrp png_ptr,
++ double fp, png_const_charp text),PNG_EMPTY);
++#endif
++
+ /* Check the user version string for compatibility, returns false if the version
+ * numbers aren't compatible.
+ */
+-PNG_EXTERN int png_user_version_check(png_structp png_ptr,
+- png_const_charp user_png_ver);
++PNG_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr,
++ png_const_charp user_png_ver),PNG_EMPTY);
+
+-/* Allocate memory for an internal libpng struct */
+-PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct,PNGARG((int type)),
++/* Internal base allocator - no messages, NULL on failure to allocate. This
++ * does, however, call the application provided allocator and that could call
++ * png_error (although that would be a bug in the application implementation.)
++ */
++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
++ * restriction so libpng has to assume that the 'free' handler, at least, might
++ * call png_error.
++ */
++PNG_INTERNAL_FUNCTION(png_structp,png_create_png_struct,
++ (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
++ png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn,
++ png_free_ptr free_fn),PNG_ALLOCATED);
++
++/* Free memory from internal libpng struct */
++PNG_INTERNAL_FUNCTION(void,png_destroy_png_struct,(png_structrp png_ptr),
++ PNG_EMPTY);
++
++/* Free an allocated jmp_buf (always succeeds) */
++PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY);
++
++/* Function to allocate memory for zlib. PNGAPI is disallowed. */
++PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size),
+ PNG_ALLOCATED);
+
+-/* Free memory from internal libpng struct */
+-PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));
+-
+-PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct_2,
+- PNGARG((int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)),
+- PNG_ALLOCATED);
+-PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
+- png_free_ptr free_fn, png_voidp mem_ptr));
+-
+-/* Free any memory that info_ptr points to and reset struct. */
+-PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
+-
+-/* Function to allocate memory for zlib. PNGAPI is disallowed. */
+-PNG_EXTERN PNG_FUNCTION(voidpf,png_zalloc,PNGARG((voidpf png_ptr, uInt items,
+- uInt size)),PNG_ALLOCATED);
+-
+ /* Function to free memory for zlib. PNGAPI is disallowed. */
+-PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));
++PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY);
+
+ /* Next four functions are used internally as callbacks. PNGCBAPI is required
+ * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to
+ * PNGCBAPI at 1.5.0
+ */
+
+-PNG_EXTERN void PNGCBAPI png_default_read_data PNGARG((png_structp png_ptr,
+- png_bytep data, png_size_t length));
++PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr,
++ png_bytep data, png_size_t length),PNG_EMPTY);
+
+ #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+-PNG_EXTERN void PNGCBAPI png_push_fill_buffer PNGARG((png_structp png_ptr,
+- png_bytep buffer, png_size_t length));
++PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr,
++ png_bytep buffer, png_size_t length),PNG_EMPTY);
+ #endif
+
+-PNG_EXTERN void PNGCBAPI png_default_write_data PNGARG((png_structp png_ptr,
+- png_bytep data, png_size_t length));
++PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr,
++ png_bytep data, png_size_t length),PNG_EMPTY);
+
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+ # ifdef PNG_STDIO_SUPPORTED
+-PNG_EXTERN void PNGCBAPI png_default_flush PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_flush,(png_structp png_ptr),
++ PNG_EMPTY);
+ # endif
+ #endif
+
+ /* Reset the CRC variable */
+-PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY);
+
+ /* Write the "data" buffer to whatever output you are using */
+-PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr,
+- png_const_bytep data, png_size_t length));
++PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr,
++ png_const_bytep data, png_size_t length),PNG_EMPTY);
+
+ /* Read and check the PNG file signature */
+-PNG_EXTERN void png_read_sig PNGARG((png_structp png_ptr, png_infop info_ptr));
++PNG_INTERNAL_FUNCTION(void,png_read_sig,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
+
+ /* Read the chunk header (length + type name) */
+-PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(png_uint_32,png_read_chunk_header,(png_structrp png_ptr),
++ PNG_EMPTY);
+
+ /* Read data from whatever input you are using into the "data" buffer */
+-PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,
+- png_size_t length));
++PNG_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data,
++ png_size_t length),PNG_EMPTY);
+
+ /* Read bytes into buf, and update png_ptr->crc */
+-PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,
+- png_size_t length));
+-
+-/* Decompress data in a chunk that uses compression */
+-#if defined(PNG_READ_COMPRESSED_TEXT_SUPPORTED)
+-PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,
+- int comp_type, png_size_t chunklength, png_size_t prefix_length,
+- png_size_t *data_length));
+-#endif
++PNG_INTERNAL_FUNCTION(void,png_crc_read,(png_structrp png_ptr, png_bytep buf,
++ png_uint_32 length),PNG_EMPTY);
+
+ /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
+-PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));
++PNG_INTERNAL_FUNCTION(int,png_crc_finish,(png_structrp png_ptr,
++ png_uint_32 skip),PNG_EMPTY);
+
+ /* Read the CRC from the file and compare it to the libpng calculated CRC */
+-PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(int,png_crc_error,(png_structrp png_ptr),PNG_EMPTY);
+
+ /* Calculate the CRC over a section of data. Note that we are only
+ * passing a maximum of 64K on systems that have this as a memory limit,
+ * since this is the maximum buffer size we can specify.
+ */
+-PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr,
+- png_const_bytep ptr, png_size_t length));
++PNG_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr,
++ png_const_bytep ptr, png_size_t length),PNG_EMPTY);
+
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+-PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY);
+ #endif
+
+ /* Write various chunks */
+@@ -606,317 +1046,256 @@
+ /* Write the IHDR chunk, and update the png_struct with the necessary
+ * information.
+ */
+-PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
+- png_uint_32 height,
+- int bit_depth, int color_type, int compression_method, int filter_method,
+- int interlace_method));
++PNG_INTERNAL_FUNCTION(void,png_write_IHDR,(png_structrp png_ptr,
++ png_uint_32 width, png_uint_32 height, int bit_depth, int color_type,
++ int compression_method, int filter_method, int interlace_method),PNG_EMPTY);
+
+-PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr,
+- png_const_colorp palette, png_uint_32 num_pal));
++PNG_INTERNAL_FUNCTION(void,png_write_PLTE,(png_structrp png_ptr,
++ png_const_colorp palette, png_uint_32 num_pal),PNG_EMPTY);
+
+-PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,
+- png_size_t length));
++PNG_INTERNAL_FUNCTION(void,png_compress_IDAT,(png_structrp png_ptr,
++ png_const_bytep row_data, png_alloc_size_t row_data_length, int flush),
++ PNG_EMPTY);
+
+-PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_write_IEND,(png_structrp png_ptr),PNG_EMPTY);
+
+ #ifdef PNG_WRITE_gAMA_SUPPORTED
+-# ifdef PNG_FLOATING_POINT_SUPPORTED
+-PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));
+-# endif
+-# ifdef PNG_FIXED_POINT_SUPPORTED
+-PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr,
+- png_fixed_point file_gamma));
+-# endif
++PNG_INTERNAL_FUNCTION(void,png_write_gAMA_fixed,(png_structrp png_ptr,
++ png_fixed_point file_gamma),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_sBIT_SUPPORTED
+-PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr,
+- png_const_color_8p sbit, int color_type));
++PNG_INTERNAL_FUNCTION(void,png_write_sBIT,(png_structrp png_ptr,
++ png_const_color_8p sbit, int color_type),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_cHRM_SUPPORTED
+-# ifdef PNG_FLOATING_POINT_SUPPORTED
+-PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
+- double white_x, double white_y,
+- double red_x, double red_y, double green_x, double green_y,
+- double blue_x, double blue_y));
+-# endif
+-PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,
+- png_fixed_point int_white_x, png_fixed_point int_white_y,
+- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
+- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
+- png_fixed_point int_blue_y));
++PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr,
++ const png_xy *xy), PNG_EMPTY);
++ /* The xy value must have been previously validated */
+ #endif
+
+ #ifdef PNG_WRITE_sRGB_SUPPORTED
+-PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
+- int intent));
++PNG_INTERNAL_FUNCTION(void,png_write_sRGB,(png_structrp png_ptr,
++ int intent),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_iCCP_SUPPORTED
+-PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,
+- png_const_charp name, int compression_type,
+- png_const_charp profile, int proflen));
+- /* Note to maintainer: profile should be png_bytep */
++PNG_INTERNAL_FUNCTION(void,png_write_iCCP,(png_structrp png_ptr,
++ png_const_charp name, png_const_bytep profile), PNG_EMPTY);
++ /* The profile must have been previously validated for correctness, the
++ * length comes from the first four bytes. Only the base, deflate,
++ * compression is supported.
++ */
+ #endif
+
+ #ifdef PNG_WRITE_sPLT_SUPPORTED
+-PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,
+- png_const_sPLT_tp palette));
++PNG_INTERNAL_FUNCTION(void,png_write_sPLT,(png_structrp png_ptr,
++ png_const_sPLT_tp palette),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_tRNS_SUPPORTED
+-PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr,
++PNG_INTERNAL_FUNCTION(void,png_write_tRNS,(png_structrp png_ptr,
+ png_const_bytep trans, png_const_color_16p values, int number,
+- int color_type));
++ int color_type),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_bKGD_SUPPORTED
+-PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,
+- png_const_color_16p values, int color_type));
++PNG_INTERNAL_FUNCTION(void,png_write_bKGD,(png_structrp png_ptr,
++ png_const_color_16p values, int color_type),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_hIST_SUPPORTED
+-PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr,
+- png_const_uint_16p hist, int num_hist));
++PNG_INTERNAL_FUNCTION(void,png_write_hIST,(png_structrp png_ptr,
++ png_const_uint_16p hist, int num_hist),PNG_EMPTY);
+ #endif
+
+ /* Chunks that have keywords */
+-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
+- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+-PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
+- png_const_charp key, png_charpp new_key));
+-#endif
+-
+ #ifdef PNG_WRITE_tEXt_SUPPORTED
+-PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_const_charp key,
+- png_const_charp text, png_size_t text_len));
++PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr,
++ png_const_charp key, png_const_charp text, png_size_t text_len),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_zTXt_SUPPORTED
+-PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_const_charp key,
+- png_const_charp text, png_size_t text_len, int compression));
++PNG_INTERNAL_FUNCTION(void,png_write_zTXt,(png_structrp png_ptr, png_const_charp
++ key, png_const_charp text, int compression),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_iTXt_SUPPORTED
+-PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,
++PNG_INTERNAL_FUNCTION(void,png_write_iTXt,(png_structrp png_ptr,
+ int compression, png_const_charp key, png_const_charp lang,
+- png_const_charp lang_key, png_const_charp text));
++ png_const_charp lang_key, png_const_charp text),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */
+-PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,
+- png_infop info_ptr, png_const_textp text_ptr, int num_text));
++PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_textp text_ptr, int num_text),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_oFFs_SUPPORTED
+-PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,
+- png_int_32 x_offset, png_int_32 y_offset, int unit_type));
++PNG_INTERNAL_FUNCTION(void,png_write_oFFs,(png_structrp png_ptr,
++ png_int_32 x_offset, png_int_32 y_offset, int unit_type),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_pCAL_SUPPORTED
+-PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,
+- png_int_32 X0, png_int_32 X1, int type, int nparams,
+- png_const_charp units, png_charpp params));
++PNG_INTERNAL_FUNCTION(void,png_write_pCAL,(png_structrp png_ptr,
++ png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
++ png_const_charp units, png_charpp params),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_pHYs_SUPPORTED
+-PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,
++PNG_INTERNAL_FUNCTION(void,png_write_pHYs,(png_structrp png_ptr,
+ png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
+- int unit_type));
++ int unit_type),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_tIME_SUPPORTED
+-PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,
+- png_const_timep mod_time));
++PNG_INTERNAL_FUNCTION(void,png_write_tIME,(png_structrp png_ptr,
++ png_const_timep mod_time),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_WRITE_sCAL_SUPPORTED
+-PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,
+- int unit, png_const_charp width, png_const_charp height));
++PNG_INTERNAL_FUNCTION(void,png_write_sCAL_s,(png_structrp png_ptr,
++ int unit, png_const_charp width, png_const_charp height),PNG_EMPTY);
+ #endif
+
+ /* Called when finished processing a row of data */
+-PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_write_finish_row,(png_structrp png_ptr),
++ PNG_EMPTY);
+
+ /* Internal use only. Called before first row of data */
+-PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_write_start_row,(png_structrp png_ptr),
++ PNG_EMPTY);
+
+-/* Combine a row of data, dealing with alpha, etc. if requested */
+-PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,
+- int mask));
++/* Combine a row of data, dealing with alpha, etc. if requested. 'row' is an
++ * array of png_ptr->width pixels. If the image is not interlaced or this
++ * is the final pass this just does a memcpy, otherwise the "display" flag
++ * is used to determine whether to copy pixels that are not in the current pass.
++ *
++ * Because 'png_do_read_interlace' (below) replicates pixels this allows this
++ * function to achieve the documented 'blocky' appearance during interlaced read
++ * if display is 1 and the 'sparkle' appearance, where existing pixels in 'row'
++ * are not changed if they are not in the current pass, when display is 0.
++ *
++ * 'display' must be 0 or 1, otherwise the memcpy will be done regardless.
++ *
++ * The API always reads from the png_struct row buffer and always assumes that
++ * it is full width (png_do_read_interlace has already been called.)
++ *
++ * This function is only ever used to write to row buffers provided by the
++ * caller of the relevant libpng API and the row must have already been
++ * transformed by the read transformations.
++ *
++ * The PNG_USE_COMPILE_TIME_MASKS option causes generation of pre-computed
++ * bitmasks for use within the code, otherwise runtime generated masks are used.
++ * The default is compile time masks.
++ */
++#ifndef PNG_USE_COMPILE_TIME_MASKS
++# define PNG_USE_COMPILE_TIME_MASKS 1
++#endif
++PNG_INTERNAL_FUNCTION(void,png_combine_row,(png_const_structrp png_ptr,
++ png_bytep row, int display),PNG_EMPTY);
+
+ #ifdef PNG_READ_INTERLACING_SUPPORTED
+-/* Expand an interlaced row */
+-/* OLD pre-1.0.9 interface:
+-PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,
+- png_bytep row, int pass, png_uint_32 transformations));
++/* Expand an interlaced row: the 'row_info' describes the pass data that has
++ * been read in and must correspond to the pixels in 'row', the pixels are
++ * expanded (moved apart) in 'row' to match the final layout, when doing this
++ * the pixels are *replicated* to the intervening space. This is essential for
++ * the correct operation of png_combine_row, above.
+ */
+-PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_do_read_interlace,(png_row_infop row_info,
++ png_bytep row, int pass, png_uint_32 transformations),PNG_EMPTY);
+ #endif
+
+ /* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */
+
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* Grab pixels out of a row for an interlaced pass */
+-PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,
+- png_bytep row, int pass));
++PNG_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info,
++ png_bytep row, int pass),PNG_EMPTY);
+ #endif
+
+-/* Unfilter a row */
+-PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,
+- png_row_infop row_info, png_bytep row, png_const_bytep prev_row,
+- int filter));
++/* Unfilter a row: check the filter value before calling this, there is no point
++ * calling it for PNG_FILTER_VALUE_NONE.
++ */
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop
++ row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY);
++
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info,
++ png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop
++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_neon,(png_row_infop
++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_neon,(png_row_infop
++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_neon,(png_row_infop
++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop
++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+
+ /* Choose the best filter to use and filter the row data */
+-PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,
+- png_row_infop row_info));
++PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
++ png_row_infop row_info),PNG_EMPTY);
+
+-/* Finish a row while reading, dealing with interlacing passes, etc. */
+-PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));
++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++PNG_INTERNAL_FUNCTION(void,png_read_IDAT_data,(png_structrp png_ptr,
++ png_bytep output, png_alloc_size_t avail_out),PNG_EMPTY);
++ /* Read 'avail_out' bytes of data from the IDAT stream. If the output buffer
++ * is NULL the function checks, instead, for the end of the stream. In this
++ * case a benign error will be issued if the stream end is not found or if
++ * extra data has to be consumed.
++ */
++PNG_INTERNAL_FUNCTION(void,png_read_finish_IDAT,(png_structrp png_ptr),
++ PNG_EMPTY);
++ /* This cleans up when the IDAT LZ stream does not end when the last image
++ * byte is read; there is still some pending input.
++ */
++
++PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr),
++ PNG_EMPTY);
++ /* Finish a row while reading, dealing with interlacing passes, etc. */
++#endif /* SEQUENTIAL_READ */
+
+ /* Initialize the row buffers, etc. */
+-PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY);
+
+ #ifdef PNG_READ_TRANSFORMS_SUPPORTED
+ /* Optional call to update the users info structure */
+-PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
++PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
+ #endif
+
+-/* These are the functions that do the transformations */
+-#ifdef PNG_READ_FILLER_SUPPORTED
+-PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,
+- png_bytep row, png_uint_32 filler, png_uint_32 flags));
+-#endif
+-
+-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+-PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+-PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+-PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+-PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
++/* Shared transform functions, defined in pngtran.c */
+ #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
+ defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+-PNG_EXTERN void png_do_strip_channel PNGARG((png_row_infop row_info,
+- png_bytep row, int at_start));
++PNG_INTERNAL_FUNCTION(void,png_do_strip_channel,(png_row_infop row_info,
++ png_bytep row, int at_start),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_16BIT_SUPPORTED
+ #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+-PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info,
+- png_bytep row));
++PNG_INTERNAL_FUNCTION(void,png_do_swap,(png_row_infop row_info,
++ png_bytep row),PNG_EMPTY);
+ #endif
+ #endif
+
+ #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
+ defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+-PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+-PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr,
+- png_row_infop row_info, png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+-PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_PACK_SUPPORTED
+-PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_SHIFT_SUPPORTED
+-PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info,
+- png_bytep row, png_const_color_8p sig_bits));
++PNG_INTERNAL_FUNCTION(void,png_do_packswap,(png_row_infop row_info,
++ png_bytep row),PNG_EMPTY);
+ #endif
+
+ #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+-PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+-PNG_EXTERN void png_do_scale_16_to_8 PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+-PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_READ_QUANTIZE_SUPPORTED
+-PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info,
+- png_bytep row, png_const_bytep palette_lookup,
+- png_const_bytep quantize_lookup));
+-
+-# ifdef PNG_CORRECT_PALETTE_SUPPORTED
+-PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
+- png_colorp palette, int num_palette));
+-# endif
++PNG_INTERNAL_FUNCTION(void,png_do_invert,(png_row_infop row_info,
++ png_bytep row),PNG_EMPTY);
+ #endif
+
+ #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+-PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info,
+- png_bytep row));
+-#endif
+-
+-#ifdef PNG_WRITE_PACK_SUPPORTED
+-PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,
+- png_bytep row, png_uint_32 bit_depth));
+-#endif
+-
+-#ifdef PNG_WRITE_SHIFT_SUPPORTED
+-PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info,
+- png_bytep row, png_const_color_8p bit_depth));
+-#endif
+-
+-#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
+- defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+-PNG_EXTERN void png_do_compose PNGARG((png_row_infop row_info,
+- png_bytep row, png_structp png_ptr));
+-#endif
+-
+-#ifdef PNG_READ_GAMMA_SUPPORTED
+-PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info,
+- png_bytep row, png_structp png_ptr));
+-#endif
+-
+-#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+-PNG_EXTERN void png_do_encode_alpha PNGARG((png_row_infop row_info,
+- png_bytep row, png_structp png_ptr));
+-#endif
+-
+-#ifdef PNG_READ_EXPAND_SUPPORTED
+-PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,
+- png_bytep row, png_const_colorp palette, png_const_bytep trans,
+- int num_trans));
+-PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
+- png_bytep row, png_const_color_16p trans_color));
+-#endif
+-
+-#ifdef PNG_READ_EXPAND_16_SUPPORTED
+-PNG_EXTERN void png_do_expand_16 PNGARG((png_row_infop row_info,
+- png_bytep row));
++PNG_INTERNAL_FUNCTION(void,png_do_bgr,(png_row_infop row_info,
++ png_bytep row),PNG_EMPTY);
+ #endif
+
+ /* The following decodes the appropriate chunks, and does error correction,
+@@ -924,208 +1303,283 @@
+ */
+
+ /* Decode the IHDR chunk */
+-PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
+-PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
+-PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_IHDR,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_handle_PLTE,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_handle_IEND,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+
+ #ifdef PNG_READ_bKGD_SUPPORTED
+-PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_bKGD,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_cHRM_SUPPORTED
+-PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_cHRM,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_gAMA_SUPPORTED
+-PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_gAMA,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_hIST_SUPPORTED
+-PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_hIST,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_iCCP_SUPPORTED
+-PNG_EXTERN void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
+-#endif /* PNG_READ_iCCP_SUPPORTED */
++PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++#endif /* READ_iCCP */
+
+ #ifdef PNG_READ_iTXt_SUPPORTED
+-PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_oFFs_SUPPORTED
+-PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_oFFs,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_pCAL_SUPPORTED
+-PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_pCAL,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_pHYs_SUPPORTED
+-PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_pHYs,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_sBIT_SUPPORTED
+-PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_sBIT,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_sCAL_SUPPORTED
+-PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_sCAL,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_sPLT_SUPPORTED
+-PNG_EXTERN void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
+-#endif /* PNG_READ_sPLT_SUPPORTED */
++PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++#endif /* READ_sPLT */
+
+ #ifdef PNG_READ_sRGB_SUPPORTED
+-PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_tEXt_SUPPORTED
+-PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_tEXt,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_tIME_SUPPORTED
+-PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_tIME,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_tRNS_SUPPORTED
+-PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_tRNS,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_zTXt_SUPPORTED
+-PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
+- png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+ #endif
+
+-PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,
+- png_infop info_ptr, png_uint_32 length));
++PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_structrp png_ptr,
++ png_uint_32 chunk_name),PNG_EMPTY);
+
+-PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,
+- png_const_bytep chunk_name));
++PNG_INTERNAL_FUNCTION(void,png_handle_unknown,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length, int keep),PNG_EMPTY);
++ /* This is the function that gets called for unknown chunks. The 'keep'
++ * argument is either non-zero for a known chunk that has been set to be
++ * handled as unknown or zero for an unknown chunk. By default the function
++ * just skips the chunk or errors out if it is critical.
++ */
++
++#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
++ defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
++PNG_INTERNAL_FUNCTION(int,png_chunk_unknown_handling,
++ (png_const_structrp png_ptr, png_uint_32 chunk_name),PNG_EMPTY);
++ /* Exactly as the API png_handle_as_unknown() except that the argument is a
++ * 32-bit chunk name, not a string.
++ */
++#endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
+
+ /* Handle the transformations for reading and writing */
+ #ifdef PNG_READ_TRANSFORMS_SUPPORTED
+-PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_do_read_transformations,(png_structrp png_ptr,
++ png_row_infop row_info),PNG_EMPTY);
+ #endif
+ #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+-PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_do_write_transformations,(png_structrp png_ptr,
++ png_row_infop row_info),PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_TRANSFORMS_SUPPORTED
+-PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_init_read_transformations,(png_structrp png_ptr),
++ PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+-PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
+-PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
+-PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));
+-PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,
+- png_uint_32 length));
+-PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));
+-PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));
+-PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,
+- png_bytep buffer, png_size_t buffer_length));
+-PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));
+-PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,
+- png_bytep buffer, png_size_t buffer_length));
+-PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));
+-PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,
+- png_infop info_ptr, png_uint_32 length));
+-PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
+-PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
+-PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));
+-PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
+-PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
+-PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));
++PNG_INTERNAL_FUNCTION(void,png_push_read_chunk,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_read_sig,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_crc_skip,(png_structrp png_ptr,
++ png_uint_32 length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_crc_finish,(png_structrp png_ptr),
++ PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_save_buffer,(png_structrp png_ptr),
++ PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr,
++ png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_read_IDAT,(png_structrp png_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_process_IDAT_data,(png_structrp png_ptr,
++ png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_process_row,(png_structrp png_ptr),
++ PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_have_info,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr,
++ png_bytep row),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_read_push_finish_row,(png_structrp png_ptr),
++ PNG_EMPTY);
+ # ifdef PNG_READ_tEXt_SUPPORTED
+-PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,
+- png_infop info_ptr, png_uint_32 length));
+-PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
++PNG_INTERNAL_FUNCTION(void,png_push_handle_tEXt,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_read_tEXt,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
+ # endif
+ # ifdef PNG_READ_zTXt_SUPPORTED
+-PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,
+- png_infop info_ptr, png_uint_32 length));
+-PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
++PNG_INTERNAL_FUNCTION(void,png_push_handle_zTXt,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_read_zTXt,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
+ # endif
+ # ifdef PNG_READ_iTXt_SUPPORTED
+-PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,
+- png_infop info_ptr, png_uint_32 length));
+-PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,
+- png_infop info_ptr));
++PNG_INTERNAL_FUNCTION(void,png_push_handle_iTXt,(png_structrp png_ptr,
++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr,
++ png_inforp info_ptr),PNG_EMPTY);
+ # endif
+
+-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
++#endif /* PROGRESSIVE_READ */
+
+-#ifdef PNG_MNG_FEATURES_SUPPORTED
+-PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,
+- png_bytep row));
+-PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,
+- png_bytep row));
++/* Added at libpng version 1.6.0 */
++#ifdef PNG_GAMMA_SUPPORTED
++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);
++ /* Synchronize the info 'valid' flags with the colorspace */
++
++PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr,
++ png_inforp info_ptr), PNG_EMPTY);
++ /* Copy the png_struct colorspace to the info_struct and call the above to
++ * synchronize the flags. Checks for NULL info_ptr and does nothing.
++ */
+ #endif
+
+ /* Added at libpng version 1.4.0 */
+-#ifdef PNG_CHECK_cHRM_SUPPORTED
+-PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,
+- png_fixed_point int_white_x, png_fixed_point int_white_y,
+- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
+- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
+- png_fixed_point int_blue_y));
++#ifdef PNG_COLORSPACE_SUPPORTED
++/* These internal functions are for maintaining the colorspace structure within
++ * a png_info or png_struct (or, indeed, both).
++ */
++PNG_INTERNAL_FUNCTION(int,png_colorspace_set_chromaticities,
++ (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy,
++ int preferred), PNG_EMPTY);
++
++PNG_INTERNAL_FUNCTION(int,png_colorspace_set_endpoints,
++ (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ,
++ int preferred), PNG_EMPTY);
++
++#ifdef PNG_sRGB_SUPPORTED
++PNG_INTERNAL_FUNCTION(int,png_colorspace_set_sRGB,(png_const_structrp png_ptr,
++ 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
++PNG_INTERNAL_FUNCTION(int,png_colorspace_set_ICC,(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, png_const_charp name,
++ png_uint_32 profile_length, png_const_bytep profile, int color_type),
++ PNG_EMPTY);
++ /* The 'name' is used for information only */
++
++/* Routines for checking parts of an ICC profile. */
++PNG_INTERNAL_FUNCTION(int,png_icc_check_length,(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, png_const_charp name,
++ png_uint_32 profile_length), PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(int,png_icc_check_header,(png_const_structrp png_ptr,
++ png_colorspacerp colorspace, png_const_charp name,
++ png_uint_32 profile_length,
++ png_const_bytep profile /* first 132 bytes only */, int color_type),
++ PNG_EMPTY);
++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);
++#ifdef PNG_sRGB_SUPPORTED
++PNG_INTERNAL_FUNCTION(void,png_icc_set_sRGB,(
++ png_const_structrp png_ptr, png_colorspacerp colorspace,
++ 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.
++ */
++#endif
++#endif /* iCCP */
++
++#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
++PNG_INTERNAL_FUNCTION(void,png_colorspace_set_rgb_coefficients,
++ (png_structrp png_ptr), PNG_EMPTY);
++ /* Set the rgb_to_gray coefficients from the colorspace Y values */
++#endif /* READ_RGB_TO_GRAY */
++#endif /* COLORSPACE */
++
++/* Added at libpng version 1.4.0 */
++PNG_INTERNAL_FUNCTION(void,png_check_IHDR,(png_const_structrp png_ptr,
++ png_uint_32 width, png_uint_32 height, int bit_depth,
++ int color_type, int interlace_type, int compression_type,
++ int filter_type),PNG_EMPTY);
++
++/* Added at libpng version 1.5.10 */
++#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
++ defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
++PNG_INTERNAL_FUNCTION(void,png_do_check_palette_indexes,
++ (png_structrp png_ptr, png_row_infop row_info),PNG_EMPTY);
+ #endif
+
+-#ifdef PNG_CHECK_cHRM_SUPPORTED
+-/* Added at libpng version 1.2.34 and 1.4.0 */
+-/* Currently only used by png_check_cHRM_fixed */
+-PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,
+- unsigned long *hi_product, unsigned long *lo_product));
+-#endif
+-
+-/* Added at libpng version 1.4.0 */
+-PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,
+- png_uint_32 width, png_uint_32 height, int bit_depth,
+- int color_type, int interlace_type, int compression_type,
+- int filter_type));
+-
+-/* Free all memory used by the read (old method - NOT DLL EXPORTED) */
+-PNG_EXTERN void png_read_destroy PNGARG((png_structp png_ptr,
+- png_infop info_ptr, png_infop end_info_ptr));
+-
+-/* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */
+-PNG_EXTERN void png_write_destroy PNGARG((png_structp png_ptr));
+-
+-#ifdef USE_FAR_KEYWORD /* memory model conversion function */
+-PNG_EXTERN void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr,
+- int check));
+-#endif /* USE_FAR_KEYWORD */
+-
+ #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
+-PNG_EXTERN PNG_FUNCTION(void, png_fixed_error, (png_structp png_ptr,
++PNG_INTERNAL_FUNCTION(void,png_fixed_error,(png_const_structrp png_ptr,
+ png_const_charp name),PNG_NORETURN);
+ #endif
+
+@@ -1133,8 +1587,8 @@
+ * the end. Always leaves the buffer nul terminated. Never errors out (and
+ * there is no error code.)
+ */
+-PNG_EXTERN size_t png_safecat(png_charp buffer, size_t bufsize, size_t pos,
+- png_const_charp string);
++PNG_INTERNAL_FUNCTION(size_t,png_safecat,(png_charp buffer, size_t bufsize,
++ size_t pos, png_const_charp string),PNG_EMPTY);
+
+ /* Various internal functions to handle formatted warning messages, currently
+ * only implemented for warnings.
+@@ -1145,8 +1599,8 @@
+ * Returns the pointer to the start of the formatted string. This utility only
+ * does unsigned values.
+ */
+-PNG_EXTERN png_charp png_format_number(png_const_charp start, png_charp end,
+- int format, png_alloc_size_t number);
++PNG_INTERNAL_FUNCTION(png_charp,png_format_number,(png_const_charp start,
++ png_charp end, int format, png_alloc_size_t number),PNG_EMPTY);
+
+ /* Convenience macro that takes an array: */
+ #define PNG_FORMAT_NUMBER(buffer,format,number) \
+@@ -1170,7 +1624,7 @@
+ #ifdef PNG_WARNINGS_SUPPORTED
+ /* New defines and members adding in libpng-1.5.4 */
+ # define PNG_WARNING_PARAMETER_SIZE 32
+-# define PNG_WARNING_PARAMETER_COUNT 8
++# define PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */
+
+ /* An l-value of this type has to be passed to the APIs below to cache the
+ * values of the parameters to a formatted warning message.
+@@ -1178,48 +1632,97 @@
+ typedef char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][
+ PNG_WARNING_PARAMETER_SIZE];
+
+-PNG_EXTERN void png_warning_parameter(png_warning_parameters p, int number,
+- png_const_charp string);
+- /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters,
+- * including the trailing '\0'.
+- */
+-PNG_EXTERN void png_warning_parameter_unsigned(png_warning_parameters p,
+- int number, int format, png_alloc_size_t value);
+- /* Use png_alloc_size_t because it is an unsigned type as big as any we
+- * need to output. Use the following for a signed value.
+- */
+-PNG_EXTERN void png_warning_parameter_signed(png_warning_parameters p,
+- int number, int format, png_int_32 value);
++PNG_INTERNAL_FUNCTION(void,png_warning_parameter,(png_warning_parameters p,
++ int number, png_const_charp string),PNG_EMPTY);
++ /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters,
++ * including the trailing '\0'.
++ */
++PNG_INTERNAL_FUNCTION(void,png_warning_parameter_unsigned,
++ (png_warning_parameters p, int number, int format, png_alloc_size_t value),
++ PNG_EMPTY);
++ /* Use png_alloc_size_t because it is an unsigned type as big as any we
++ * need to output. Use the following for a signed value.
++ */
++PNG_INTERNAL_FUNCTION(void,png_warning_parameter_signed,
++ (png_warning_parameters p, int number, int format, png_int_32 value),
++ PNG_EMPTY);
+
+-PNG_EXTERN void png_formatted_warning(png_structp png_ptr,
+- png_warning_parameters p, png_const_charp message);
+- /* 'message' follows the X/Open approach of using @1, @2 to insert
+- * parameters previously supplied using the above functions. Errors in
+- * specifying the parameters will simple result in garbage substitutions.
+- */
++PNG_INTERNAL_FUNCTION(void,png_formatted_warning,(png_const_structrp png_ptr,
++ png_warning_parameters p, png_const_charp message),PNG_EMPTY);
++ /* 'message' follows the X/Open approach of using @1, @2 to insert
++ * parameters previously supplied using the above functions. Errors in
++ * specifying the parameters will simply result in garbage substitutions.
++ */
+ #endif
+
++#ifdef PNG_BENIGN_ERRORS_SUPPORTED
++/* Application errors (new in 1.6); use these functions (declared below) for
++ * errors in the parameters or order of API function calls on read. The
++ * 'warning' should be used for an error that can be handled completely; the
++ * 'error' for one which can be handled safely but which may lose application
++ * information or settings.
++ *
++ * By default these both result in a png_error call prior to release, while in a
++ * released version the 'warning' is just a warning. However if the application
++ * explicitly disables benign errors (explicitly permitting the code to lose
++ * information) they both turn into warnings.
++ *
++ * If benign errors aren't supported they end up as the corresponding base call
++ * (png_warning or png_error.)
++ */
++PNG_INTERNAL_FUNCTION(void,png_app_warning,(png_const_structrp png_ptr,
++ png_const_charp message),PNG_EMPTY);
++ /* The application provided invalid parameters to an API function or called
++ * an API function at the wrong time, libpng can completely recover.
++ */
++
++PNG_INTERNAL_FUNCTION(void,png_app_error,(png_const_structrp png_ptr,
++ png_const_charp message),PNG_EMPTY);
++ /* As above but libpng will ignore the call, or attempt some other partial
++ * recovery from the error.
++ */
++#else
++# define png_app_warning(pp,s) png_warning(pp,s)
++# 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.
+ */
+-#if defined(PNG_READ_sCAL_SUPPORTED)
++#if defined(PNG_sCAL_SUPPORTED)
+ /* MAX_DIGITS is actually the maximum number of characters in an sCAL
+ * width or height, derived from the precision (number of significant
+- * digits - a build time settable option) and assumpitions about the
++ * digits - a build time settable option) and assumptions about the
+ * maximum ridiculous exponent.
+ */
+ #define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/)
+
+ #ifdef PNG_FLOATING_POINT_SUPPORTED
+-PNG_EXTERN void png_ascii_from_fp PNGARG((png_structp png_ptr, png_charp ascii,
+- png_size_t size, double fp, unsigned int precision));
++PNG_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr,
++ png_charp ascii, png_size_t size, double fp, unsigned int precision),
++ PNG_EMPTY);
+ #endif /* FLOATING_POINT */
+
+ #ifdef PNG_FIXED_POINT_SUPPORTED
+-PNG_EXTERN void png_ascii_from_fixed PNGARG((png_structp png_ptr,
+- png_charp ascii, png_size_t size, png_fixed_point fp));
++PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
++ png_charp ascii, png_size_t size, png_fixed_point fp),PNG_EMPTY);
+ #endif /* FIXED_POINT */
+-#endif /* READ_sCAL */
++#endif /* sCAL */
+
+ #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
+ /* An internal API to validate the format of a floating point number.
+@@ -1243,7 +1746,7 @@
+ * NOTE: The dangling E problem.
+ * There is a PNG valid floating point number in the following:
+ *
+- * PNG floating point numb1.ers are not greedy.
++ * PNG floating point numbers are not greedy.
+ *
+ * Working this out requires *TWO* character lookahead (because of the
+ * sign), the parser does not do this - it will fail at the 'r' - this
+@@ -1294,14 +1797,14 @@
+ #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
+@@ -1309,8 +1812,8 @@
+ * that omits the last character (i.e. set the size to the index of
+ * the problem character.) This has not been tested within libpng.
+ */
+-PNG_EXTERN int png_check_fp_number PNGARG((png_const_charp string,
+- png_size_t size, int *statep, png_size_tp whereami));
++PNG_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string,
++ png_size_t size, int *statep, png_size_tp whereami),PNG_EMPTY);
+
+ /* This is the same but it checks a complete string and returns true
+ * only if it just contains a floating point number. As of 1.5.4 this
+@@ -1318,11 +1821,11 @@
+ * it was valid (otherwise it returns 0.) This can be used for testing
+ * for negative or zero values using the sticky flag.
+ */
+-PNG_EXTERN int png_check_fp_string PNGARG((png_const_charp string,
+- png_size_t size));
++PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string,
++ png_size_t size),PNG_EMPTY);
+ #endif /* pCAL || sCAL */
+
+-#if defined(PNG_READ_GAMMA_SUPPORTED) ||\
++#if defined(PNG_GAMMA_SUPPORTED) ||\
+ defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
+ /* Added at libpng version 1.5.0 */
+ /* This is a utility to provide a*times/div (rounded) and indicate
+@@ -1330,29 +1833,37 @@
+ * for overflow, true (1) if no overflow, in which case *res
+ * holds the result.
+ */
+-PNG_EXTERN int png_muldiv PNGARG((png_fixed_point_p res, png_fixed_point a,
+- png_int_32 multiplied_by, png_int_32 divided_by));
++PNG_INTERNAL_FUNCTION(int,png_muldiv,(png_fixed_point_p res, png_fixed_point a,
++ png_int_32 multiplied_by, png_int_32 divided_by),PNG_EMPTY);
+ #endif
+
+ #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
+ /* Same deal, but issue a warning on overflow and return 0. */
+-PNG_EXTERN png_fixed_point png_muldiv_warn PNGARG((png_structp png_ptr,
+- png_fixed_point a, png_int_32 multiplied_by, png_int_32 divided_by));
++PNG_INTERNAL_FUNCTION(png_fixed_point,png_muldiv_warn,
++ (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by,
++ png_int_32 divided_by),PNG_EMPTY);
+ #endif
+
+-#ifdef PNG_READ_GAMMA_SUPPORTED
++#ifdef PNG_GAMMA_SUPPORTED
+ /* Calculate a reciprocal - used for gamma values. This returns
+- * 0 if the argument is 0 in order to maintain an undefined value,
++ * 0 if the argument is 0 in order to maintain an undefined value;
+ * there are no warnings.
+ */
+-PNG_EXTERN png_fixed_point png_reciprocal PNGARG((png_fixed_point a));
++PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal,(png_fixed_point a),
++ PNG_EMPTY);
+
++#ifdef PNG_READ_GAMMA_SUPPORTED
+ /* The same but gives a reciprocal of the product of two fixed point
+ * values. Accuracy is suitable for gamma calculations but this is
+- * not exact - use png_muldiv for that.
++ * not exact - use png_muldiv for that. Only required at present on read.
+ */
+-PNG_EXTERN png_fixed_point png_reciprocal2 PNGARG((png_fixed_point a,
+- png_fixed_point b));
++PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal2,(png_fixed_point a,
++ png_fixed_point b),PNG_EMPTY);
++#endif
++
++/* Return true if the gamma value is significantly different from 1.0 */
++PNG_INTERNAL_FUNCTION(int,png_gamma_significant,(png_fixed_point gamma_value),
++ PNG_EMPTY);
+ #endif
+
+ #ifdef PNG_READ_GAMMA_SUPPORTED
+@@ -1363,19 +1874,93 @@
+ * While the input is an 'unsigned' value it must actually be the
+ * correct bit value - 0..255 or 0..65535 as required.
+ */
+-PNG_EXTERN png_uint_16 png_gamma_correct PNGARG((png_structp png_ptr,
+- unsigned int value, png_fixed_point gamma_value));
+-PNG_EXTERN int png_gamma_significant PNGARG((png_fixed_point gamma_value));
+-PNG_EXTERN png_uint_16 png_gamma_16bit_correct PNGARG((unsigned int value,
+- png_fixed_point gamma_value));
+-PNG_EXTERN png_byte png_gamma_8bit_correct PNGARG((unsigned int value,
+- png_fixed_point gamma_value));
+-PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr,
+- int bit_depth));
++PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_correct,(png_structrp png_ptr,
++ unsigned int value, png_fixed_point gamma_value),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_16bit_correct,(unsigned int value,
++ png_fixed_point gamma_value),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(png_byte,png_gamma_8bit_correct,(unsigned int value,
++ png_fixed_point gamma_value),PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_destroy_gamma_table,(png_structrp png_ptr),
++ PNG_EMPTY);
++PNG_INTERNAL_FUNCTION(void,png_build_gamma_table,(png_structrp png_ptr,
++ int bit_depth),PNG_EMPTY);
+ #endif
+
+-/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
++/* SIMPLIFIED READ/WRITE SUPPORT */
++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
++ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
++/* The internal structure that png_image::opaque points to. */
++typedef struct png_control
++{
++ png_structp png_ptr;
++ png_infop info_ptr;
++ png_voidp error_buf; /* Always a jmp_buf at present. */
+
++ png_const_bytep memory; /* Memory buffer. */
++ png_size_t size; /* Size of the memory buffer. */
++
++ unsigned int for_write :1; /* Otherwise it is a read structure */
++ unsigned int owned_file :1; /* We own the file in io_ptr */
++} png_control;
++
++/* Return the pointer to the jmp_buf from a png_control: necessary because C
++ * does not reveal the type of the elements of jmp_buf.
++ */
++#ifdef __cplusplus
++# define png_control_jmp_buf(pc) (((jmp_buf*)((pc)->error_buf))[0])
++#else
++# define png_control_jmp_buf(pc) ((pc)->error_buf)
++#endif
++
++/* Utility to safely execute a piece of libpng code catching and logging any
++ * errors that might occur. Returns true on success, false on failure (either
++ * of the function or as a result of a png_error.)
++ */
++PNG_INTERNAL_CALLBACK(void,png_safe_error,(png_structp png_ptr,
++ png_const_charp error_message),PNG_NORETURN);
++
++#ifdef PNG_WARNINGS_SUPPORTED
++PNG_INTERNAL_CALLBACK(void,png_safe_warning,(png_structp png_ptr,
++ png_const_charp warning_message),PNG_EMPTY);
++#else
++# define png_safe_warning 0/*dummy argument*/
++#endif
++
++PNG_INTERNAL_FUNCTION(int,png_safe_execute,(png_imagep image,
++ int (*function)(png_voidp), png_voidp arg),PNG_EMPTY);
++
++/* Utility to log an error; this also cleans up the png_image; the function
++ * always returns 0 (false).
++ */
++PNG_INTERNAL_FUNCTION(int,png_image_error,(png_imagep image,
++ png_const_charp error_message),PNG_EMPTY);
++
++#ifndef PNG_SIMPLIFIED_READ_SUPPORTED
++/* png_image_free is used by the write code but not exported */
++PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY);
++#endif /* !SIMPLIFIED_READ */
++
++#endif /* SIMPLIFIED READ/WRITE */
++
++/* These are initialization functions for hardware specific PNG filter
++ * optimizations; list these here then select the appropriate one at compile
++ * time using the macro PNG_FILTER_OPTIMIZATIONS. If the macro is not defined
++ * the generic code is used.
++ */
++#ifdef PNG_FILTER_OPTIMIZATIONS
++PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
++ unsigned int bpp), PNG_EMPTY);
++ /* Just declare the optimization that will be used */
++#else
++ /* List *all* the possible optimizations here - this branch is required if
++ * the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in
++ * CFLAGS in place of CPPFLAGS *and* uses symbol prefixing.
++ */
++PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
++ (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
++#endif
++
++/* Maintainer: Put new private prototypes here ^ */
+
+ #include "pngdebug.h"
+
+@@ -1383,4 +1968,5 @@
+ }
+ #endif
+
++#endif /* PNG_VERSION_INFO_ONLY */
+ #endif /* PNGPRIV_H */
+--- ./jdk/src/share/native/sun/awt/libpng/pngread.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngread.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -43,6 +43,9 @@
+ */
+
+ #include "pngpriv.h"
++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
++# include <errno.h>
++#endif
+
+ #ifdef PNG_READ_SUPPORTED
+
+@@ -51,10 +54,12 @@
+ png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
+ {
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
+- warn_fn, NULL, NULL, NULL));
++#ifndef PNG_USER_MEM_SUPPORTED
++ png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
++ error_fn, warn_fn, NULL, NULL, NULL);
++#else
++ return png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
++ warn_fn, NULL, NULL, NULL);
+ }
+
+ /* Alternate create PNG structure for reading, and allocate any memory
+@@ -65,134 +70,40 @@
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
+ {
+-#endif /* PNG_USER_MEM_SUPPORTED */
+-
+-#ifdef PNG_SETJMP_SUPPORTED
+- volatile
+-#endif
+- png_structp png_ptr;
+- volatile int png_cleanup_needed = 0;
+-
+-#ifdef PNG_SETJMP_SUPPORTED
+-#ifdef USE_FAR_KEYWORD
+- jmp_buf tmp_jmpbuf;
+-#endif
+-#endif
+-
+- png_debug(1, "in png_create_read_struct");
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+- malloc_fn, mem_ptr);
+-#else
+- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+-#endif
+- if (png_ptr == NULL)
+- return (NULL);
+-
+- /* Added at libpng-1.2.6 */
+-#ifdef PNG_USER_LIMITS_SUPPORTED
+- png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
+- png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
+-
+-# ifdef PNG_USER_CHUNK_CACHE_MAX
+- /* Added at libpng-1.2.43 and 1.4.0 */
+- png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
+-# endif
+-
+-# ifdef PNG_SET_USER_CHUNK_MALLOC_MAX
+- /* Added at libpng-1.2.43 and 1.4.1 */
+- png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
+-# endif
+-#endif
+-
+-#ifdef PNG_SETJMP_SUPPORTED
+-/* Applications that neglect to set up their own setjmp() and then
+- encounter a png_error() will longjmp here. Since the jmpbuf is
+- then meaningless we abort instead of returning. */
+-#ifdef USE_FAR_KEYWORD
+- if (setjmp(tmp_jmpbuf))
+-#else
+- if (setjmp(png_jmpbuf(png_ptr))) /* Sets longjmp to match setjmp */
+-#endif
+- PNG_ABORT();
+-#ifdef USE_FAR_KEYWORD
+- png_memcpy(png_jmpbuf(png_ptr), tmp_jmpbuf, png_sizeof(jmp_buf));
+-#endif
+-#endif /* PNG_SETJMP_SUPPORTED */
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+-#endif
+-
+- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
+-
+- /* Call the general version checker (shared with read and write code): */
+- if (!png_user_version_check(png_ptr, user_png_ver))
+- png_cleanup_needed = 1;
+-
+- if (!png_cleanup_needed)
++ png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
++ error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
++#endif /* USER_MEM */
++
++ if (png_ptr != NULL)
+ {
+- /* Initialize zbuf - compression buffer */
+- png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+- png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, png_ptr->zbuf_size);
+-
+- if (png_ptr->zbuf == NULL)
+- png_cleanup_needed = 1;
++ png_ptr->mode = PNG_IS_READ_STRUCT;
++
++ /* Added in libpng-1.6.0; this can be used to detect a read structure if
++ * required (it will be zero in a write structure.)
++ */
++# ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++ png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;
++# endif
++
++# ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED
++ png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
++
++ /* In stable builds only warn if an application error can be completely
++ * handled.
++ */
++# if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
++ png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
++# endif
++# endif
++
++ /* TODO: delay this, it can be done in png_init_io (if the app doesn't
++ * do it itself) avoiding setting the default function if it is not
++ * required.
++ */
++ png_set_read_fn(png_ptr, NULL, NULL);
+ }
+
+- png_ptr->zstream.zalloc = png_zalloc;
+- png_ptr->zstream.zfree = png_zfree;
+- png_ptr->zstream.opaque = (voidpf)png_ptr;
+-
+- if (!png_cleanup_needed)
+- {
+- switch (inflateInit(&png_ptr->zstream))
+- {
+- case Z_OK:
+- break; /* Do nothing */
+-
+- case Z_MEM_ERROR:
+- png_warning(png_ptr, "zlib memory error");
+- png_cleanup_needed = 1;
+- break;
+-
+- case Z_STREAM_ERROR:
+- png_warning(png_ptr, "zlib stream error");
+- png_cleanup_needed = 1;
+- break;
+-
+- case Z_VERSION_ERROR:
+- png_warning(png_ptr, "zlib version error");
+- png_cleanup_needed = 1;
+- break;
+-
+- default: png_warning(png_ptr, "Unknown zlib error");
+- png_cleanup_needed = 1;
+- }
+- }
+-
+- if (png_cleanup_needed)
+- {
+- /* Clean up PNG structure and deallocate any memory. */
+- png_free(png_ptr, png_ptr->zbuf);
+- png_ptr->zbuf = NULL;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)png_ptr,
+- (png_free_ptr)free_fn, (png_voidp)mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)png_ptr);
+-#endif
+- return (NULL);
+- }
+-
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+-
+- png_set_read_fn(png_ptr, NULL, NULL);
+-
+-
+- return (png_ptr);
++ return png_ptr;
+ }
+
+
+@@ -206,8 +117,12 @@
+ * read if it is determined that this isn't a valid PNG file.
+ */
+ void PNGAPI
+-png_read_info(png_structp png_ptr, png_infop info_ptr)
++png_read_info(png_structrp png_ptr, png_inforp info_ptr)
+ {
++#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++ int keep;
++#endif
++
+ png_debug(1, "in png_read_info");
+
+ if (png_ptr == NULL || info_ptr == NULL)
+@@ -218,231 +133,179 @@
+
+ for (;;)
+ {
+- PNG_IHDR;
+- PNG_IDAT;
+- PNG_IEND;
+- PNG_PLTE;
+-#ifdef PNG_READ_bKGD_SUPPORTED
+- PNG_bKGD;
+-#endif
+-#ifdef PNG_READ_cHRM_SUPPORTED
+- PNG_cHRM;
+-#endif
+-#ifdef PNG_READ_gAMA_SUPPORTED
+- PNG_gAMA;
+-#endif
+-#ifdef PNG_READ_hIST_SUPPORTED
+- PNG_hIST;
+-#endif
+-#ifdef PNG_READ_iCCP_SUPPORTED
+- PNG_iCCP;
+-#endif
+-#ifdef PNG_READ_iTXt_SUPPORTED
+- PNG_iTXt;
+-#endif
+-#ifdef PNG_READ_oFFs_SUPPORTED
+- PNG_oFFs;
+-#endif
+-#ifdef PNG_READ_pCAL_SUPPORTED
+- PNG_pCAL;
+-#endif
+-#ifdef PNG_READ_pHYs_SUPPORTED
+- PNG_pHYs;
+-#endif
+-#ifdef PNG_READ_sBIT_SUPPORTED
+- PNG_sBIT;
+-#endif
+-#ifdef PNG_READ_sCAL_SUPPORTED
+- PNG_sCAL;
+-#endif
+-#ifdef PNG_READ_sPLT_SUPPORTED
+- PNG_sPLT;
+-#endif
+-#ifdef PNG_READ_sRGB_SUPPORTED
+- PNG_sRGB;
+-#endif
+-#ifdef PNG_READ_tEXt_SUPPORTED
+- PNG_tEXt;
+-#endif
+-#ifdef PNG_READ_tIME_SUPPORTED
+- PNG_tIME;
+-#endif
+-#ifdef PNG_READ_tRNS_SUPPORTED
+- PNG_tRNS;
+-#endif
+-#ifdef PNG_READ_zTXt_SUPPORTED
+- PNG_zTXt;
+-#endif
+ png_uint_32 length = png_read_chunk_header(png_ptr);
+- PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
++ png_uint_32 chunk_name = png_ptr->chunk_name;
++
++ /* IDAT logic needs to happen here to simplify getting the two flags
++ * right.
++ */
++ if (chunk_name == png_IDAT)
++ {
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "Missing IHDR before IDAT");
++
++ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
++ (png_ptr->mode & PNG_HAVE_PLTE) == 0)
++ png_chunk_error(png_ptr, "Missing PLTE before IDAT");
++
++ else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
++ png_chunk_benign_error(png_ptr, "Too many IDATs found");
++
++ png_ptr->mode |= PNG_HAVE_IDAT;
++ }
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
++ png_ptr->mode |= PNG_AFTER_IDAT;
+
+ /* This should be a binary subdivision search or a hash for
+ * matching the chunk name rather than a linear search.
+ */
+- if (!png_memcmp(chunk_name, png_IDAT, 4))
+- if (png_ptr->mode & PNG_AFTER_IDAT)
+- png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
+-
+- if (!png_memcmp(chunk_name, png_IHDR, 4))
++ if (chunk_name == png_IHDR)
+ png_handle_IHDR(png_ptr, info_ptr, length);
+
+- else if (!png_memcmp(chunk_name, png_IEND, 4))
++ else if (chunk_name == png_IEND)
+ png_handle_IEND(png_ptr, info_ptr, length);
+
+ #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- else if (png_handle_as_unknown(png_ptr, chunk_name))
++ else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
+ {
+- if (!png_memcmp(chunk_name, png_IDAT, 4))
+- png_ptr->mode |= PNG_HAVE_IDAT;
+-
+- png_handle_unknown(png_ptr, info_ptr, length);
+-
+- if (!png_memcmp(chunk_name, png_PLTE, 4))
++ png_handle_unknown(png_ptr, info_ptr, length, keep);
++
++ if (chunk_name == png_PLTE)
+ png_ptr->mode |= PNG_HAVE_PLTE;
+
+- else if (!png_memcmp(chunk_name, png_IDAT, 4))
++ else if (chunk_name == png_IDAT)
+ {
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before IDAT");
+-
+- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+- !(png_ptr->mode & PNG_HAVE_PLTE))
+- png_error(png_ptr, "Missing PLTE before IDAT");
+-
++ png_ptr->idat_size = 0; /* It has been consumed */
+ break;
+ }
+ }
+ #endif
+- else if (!png_memcmp(chunk_name, png_PLTE, 4))
++ else if (chunk_name == png_PLTE)
+ png_handle_PLTE(png_ptr, info_ptr, length);
+
+- else if (!png_memcmp(chunk_name, png_IDAT, 4))
++ else if (chunk_name == png_IDAT)
+ {
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before IDAT");
+-
+- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+- !(png_ptr->mode & PNG_HAVE_PLTE))
+- png_error(png_ptr, "Missing PLTE before IDAT");
+-
+ png_ptr->idat_size = length;
+- png_ptr->mode |= PNG_HAVE_IDAT;
+ break;
+ }
+
+ #ifdef PNG_READ_bKGD_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_bKGD, 4))
++ else if (chunk_name == png_bKGD)
+ png_handle_bKGD(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_cHRM_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_cHRM, 4))
++ else if (chunk_name == png_cHRM)
+ png_handle_cHRM(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_gAMA_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_gAMA, 4))
++ else if (chunk_name == png_gAMA)
+ png_handle_gAMA(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_hIST_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_hIST, 4))
++ else if (chunk_name == png_hIST)
+ png_handle_hIST(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_oFFs_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_oFFs, 4))
++ else if (chunk_name == png_oFFs)
+ png_handle_oFFs(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_pCAL_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_pCAL, 4))
++ else if (chunk_name == png_pCAL)
+ png_handle_pCAL(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sCAL_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sCAL, 4))
++ else if (chunk_name == png_sCAL)
+ png_handle_sCAL(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_pHYs_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_pHYs, 4))
++ else if (chunk_name == png_pHYs)
+ png_handle_pHYs(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sBIT_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sBIT, 4))
++ else if (chunk_name == png_sBIT)
+ png_handle_sBIT(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sRGB_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sRGB, 4))
++ else if (chunk_name == png_sRGB)
+ png_handle_sRGB(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_iCCP_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_iCCP, 4))
++ else if (chunk_name == png_iCCP)
+ png_handle_iCCP(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sPLT_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sPLT, 4))
++ else if (chunk_name == png_sPLT)
+ png_handle_sPLT(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_tEXt_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_tEXt, 4))
++ else if (chunk_name == png_tEXt)
+ png_handle_tEXt(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_tIME_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_tIME, 4))
++ else if (chunk_name == png_tIME)
+ png_handle_tIME(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_tRNS_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_tRNS, 4))
++ else if (chunk_name == png_tRNS)
+ png_handle_tRNS(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_zTXt_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_zTXt, 4))
++ else if (chunk_name == png_zTXt)
+ png_handle_zTXt(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_iTXt_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_iTXt, 4))
++ else if (chunk_name == png_iTXt)
+ png_handle_iTXt(png_ptr, info_ptr, length);
+ #endif
+
+ else
+- png_handle_unknown(png_ptr, info_ptr, length);
++ png_handle_unknown(png_ptr, info_ptr, length,
++ PNG_HANDLE_CHUNK_AS_DEFAULT);
+ }
+ }
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
++#endif /* SEQUENTIAL_READ */
+
+ /* Optional call to update the users info_ptr structure */
+ void PNGAPI
+-png_read_update_info(png_structp png_ptr, png_infop info_ptr)
++png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)
+ {
+ png_debug(1, "in png_read_update_info");
+
+- if (png_ptr == NULL)
+- return;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+- png_read_start_row(png_ptr);
+-
+- else
+- png_warning(png_ptr,
+- "Ignoring extra png_read_update_info() call;"
+- " row buffer not reallocated");
+-
+-#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+- png_read_transform_info(png_ptr, info_ptr);
+-#else
+- PNG_UNUSED(info_ptr)
+-#endif
++ if (png_ptr != NULL)
++ {
++ if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
++ {
++ png_read_start_row(png_ptr);
++
++# ifdef PNG_READ_TRANSFORMS_SUPPORTED
++ png_read_transform_info(png_ptr, info_ptr);
++# else
++ PNG_UNUSED(info_ptr)
++# endif
++ }
++
++ /* New in 1.6.0 this avoids the bug of doing the initializations twice */
++ else
++ png_app_error(png_ptr,
++ "png_read_update_info/png_start_read_image: duplicate call");
++ }
+ }
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+@@ -452,86 +315,166 @@
+ * If the user doesn't call this, we will do it ourselves.
+ */
+ void PNGAPI
+-png_start_read_image(png_structp png_ptr)
++png_start_read_image(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_start_read_image");
+
++ if (png_ptr != NULL)
++ {
++ if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
++ png_read_start_row(png_ptr);
++
++ /* New in 1.6.0 this avoids the bug of doing the initializations twice */
++ else
++ png_app_error(png_ptr,
++ "png_start_read_image/png_read_update_info: duplicate call");
++ }
++}
++#endif /* SEQUENTIAL_READ */
++
++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++#ifdef PNG_MNG_FEATURES_SUPPORTED
++/* Undoes intrapixel differencing,
++ * NOTE: this is apparently only supported in the 'sequential' reader.
++ */
++static void
++png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
++{
++ png_debug(1, "in png_do_read_intrapixel");
++
++ if (
++ (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
++ {
++ int bytes_per_pixel;
++ png_uint_32 row_width = row_info->width;
++
++ if (row_info->bit_depth == 8)
++ {
++ png_bytep rp;
++ png_uint_32 i;
++
++ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
++ bytes_per_pixel = 3;
++
++ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
++ bytes_per_pixel = 4;
++
++ else
++ return;
++
++ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
++ {
++ *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff);
++ *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff);
++ }
++ }
++ else if (row_info->bit_depth == 16)
++ {
++ png_bytep rp;
++ png_uint_32 i;
++
++ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
++ bytes_per_pixel = 6;
++
++ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
++ bytes_per_pixel = 8;
++
++ else
++ return;
++
++ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
++ {
++ png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1);
++ png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);
++ png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);
++ png_uint_32 red = (s0 + s1 + 65536) & 0xffff;
++ png_uint_32 blue = (s2 + s1 + 65536) & 0xffff;
++ *(rp ) = (png_byte)((red >> 8) & 0xff);
++ *(rp + 1) = (png_byte)(red & 0xff);
++ *(rp + 4) = (png_byte)((blue >> 8) & 0xff);
++ *(rp + 5) = (png_byte)(blue & 0xff);
++ }
++ }
++ }
++}
++#endif /* MNG_FEATURES */
++
++void PNGAPI
++png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
++{
++ png_row_info row_info;
++
+ if (png_ptr == NULL)
+ return;
+
+- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
+- png_read_start_row(png_ptr);
+- else
+- png_warning(png_ptr,
+- "Ignoring extra png_start_read_image() call;"
+- " row buffer not reallocated");
+-}
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+-
+-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+-void PNGAPI
+-png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
+-{
+- PNG_IDAT;
+-#ifdef PNG_READ_INTERLACING_SUPPORTED
+- PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
+- 0xff};
+- PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
+-#endif
+- int ret;
+-
+- if (png_ptr == NULL)
+- return;
+-
+ png_debug2(1, "in png_read_row (row %lu, pass %d)",
+ (unsigned long)png_ptr->row_number, png_ptr->pass);
+
+- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
++ /* png_read_start_row sets the information (in particular iwidth) for this
++ * interlace pass.
++ */
++ if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
+ png_read_start_row(png_ptr);
+
++ /* 1.5.6: row_info moved out of png_struct to a local here. */
++ row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
++ row_info.color_type = png_ptr->color_type;
++ row_info.bit_depth = png_ptr->bit_depth;
++ row_info.channels = png_ptr->channels;
++ row_info.pixel_depth = png_ptr->pixel_depth;
++ row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
++
++#ifdef PNG_WARNINGS_SUPPORTED
+ if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+ {
+ /* Check for transforms that have been set but were defined out */
+ #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
+- if (png_ptr->transformations & PNG_INVERT_MONO)
++ if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
+ png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
+ #endif
+
+ #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
+- if (png_ptr->transformations & PNG_FILLER)
++ if ((png_ptr->transformations & PNG_FILLER) != 0)
+ png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
+ #endif
+
+ #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
+ !defined(PNG_READ_PACKSWAP_SUPPORTED)
+- if (png_ptr->transformations & PNG_PACKSWAP)
++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
+ png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
+ #endif
+
+ #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
+- if (png_ptr->transformations & PNG_PACK)
++ if ((png_ptr->transformations & PNG_PACK) != 0)
+ png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
+ #endif
+
+ #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
+- if (png_ptr->transformations & PNG_SHIFT)
++ if ((png_ptr->transformations & PNG_SHIFT) != 0)
+ png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
+ #endif
+
+ #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
+- if (png_ptr->transformations & PNG_BGR)
++ if ((png_ptr->transformations & PNG_BGR) != 0)
+ png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
+ #endif
+
+ #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
+- if (png_ptr->transformations & PNG_SWAP_BYTES)
++ if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
+ png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
+ #endif
+ }
++#endif /* WARNINGS */
+
+ #ifdef PNG_READ_INTERLACING_SUPPORTED
+- /* If interlaced and we do not need a new row, combine row and return */
+- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
++ /* If interlaced and we do not need a new row, combine row and return.
++ * Notice that the pixels we have from previous rows have been transformed
++ * already; we can only combine like with like (transformed or
++ * untransformed) and, because of the libpng API for interlaced images, this
++ * means we must transform before de-interlacing.
++ */
++ if (png_ptr->interlaced != 0 &&
++ (png_ptr->transformations & PNG_INTERLACE) != 0)
+ {
+ switch (png_ptr->pass)
+ {
+@@ -539,8 +482,7 @@
+ if (png_ptr->row_number & 0x07)
+ {
+ if (dsp_row != NULL)
+- png_combine_row(png_ptr, dsp_row,
+- png_pass_dsp_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, dsp_row, 1/*display*/);
+ png_read_finish_row(png_ptr);
+ return;
+ }
+@@ -550,8 +492,7 @@
+ if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
+ {
+ if (dsp_row != NULL)
+- png_combine_row(png_ptr, dsp_row,
+- png_pass_dsp_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, dsp_row, 1/*display*/);
+
+ png_read_finish_row(png_ptr);
+ return;
+@@ -562,8 +503,7 @@
+ if ((png_ptr->row_number & 0x07) != 4)
+ {
+ if (dsp_row != NULL && (png_ptr->row_number & 4))
+- png_combine_row(png_ptr, dsp_row,
+- png_pass_dsp_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, dsp_row, 1/*display*/);
+
+ png_read_finish_row(png_ptr);
+ return;
+@@ -574,8 +514,7 @@
+ if ((png_ptr->row_number & 3) || png_ptr->width < 3)
+ {
+ if (dsp_row != NULL)
+- png_combine_row(png_ptr, dsp_row,
+- png_pass_dsp_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, dsp_row, 1/*display*/);
+
+ png_read_finish_row(png_ptr);
+ return;
+@@ -586,19 +525,18 @@
+ if ((png_ptr->row_number & 3) != 2)
+ {
+ if (dsp_row != NULL && (png_ptr->row_number & 2))
+- png_combine_row(png_ptr, dsp_row,
+- png_pass_dsp_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, dsp_row, 1/*display*/);
+
+ png_read_finish_row(png_ptr);
+ return;
+ }
+ break;
++
+ case 5:
+ if ((png_ptr->row_number & 1) || png_ptr->width < 2)
+ {
+ if (dsp_row != NULL)
+- png_combine_row(png_ptr, dsp_row,
+- png_pass_dsp_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, dsp_row, 1/*display*/);
+
+ png_read_finish_row(png_ptr);
+ return;
+@@ -607,7 +545,7 @@
+
+ default:
+ case 6:
+- if (!(png_ptr->row_number & 1))
++ if ((png_ptr->row_number & 1) == 0)
+ {
+ png_read_finish_row(png_ptr);
+ return;
+@@ -617,117 +555,85 @@
+ }
+ #endif
+
+- if (!(png_ptr->mode & PNG_HAVE_IDAT))
++ if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
+ png_error(png_ptr, "Invalid attempt to read row data");
+
+- png_ptr->zstream.next_out = png_ptr->row_buf;
+- png_ptr->zstream.avail_out =
+- (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
+- png_ptr->iwidth) + 1);
+-
+- do
++ /* Fill the row with IDAT data: */
++ png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);
++
++ if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
+ {
+- if (!(png_ptr->zstream.avail_in))
+- {
+- while (!png_ptr->idat_size)
+- {
+- png_crc_finish(png_ptr, 0);
+-
+- png_ptr->idat_size = png_read_chunk_header(png_ptr);
+- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+- png_error(png_ptr, "Not enough image data");
+- }
+- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
+- png_ptr->zstream.next_in = png_ptr->zbuf;
+- if (png_ptr->zbuf_size > png_ptr->idat_size)
+- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
+- png_crc_read(png_ptr, png_ptr->zbuf,
+- (png_size_t)png_ptr->zstream.avail_in);
+- png_ptr->idat_size -= png_ptr->zstream.avail_in;
+- }
+-
+- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+-
+- if (ret == Z_STREAM_END)
+- {
+- if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
+- png_ptr->idat_size)
+- png_benign_error(png_ptr, "Extra compressed data");
+- png_ptr->mode |= PNG_AFTER_IDAT;
+- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+- break;
+- }
+-
+- if (ret != Z_OK)
+- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
+- "Decompression error");
+-
+- } while (png_ptr->zstream.avail_out);
+-
+- png_ptr->row_info.color_type = png_ptr->color_type;
+- png_ptr->row_info.width = png_ptr->iwidth;
+- png_ptr->row_info.channels = png_ptr->channels;
+- png_ptr->row_info.bit_depth = png_ptr->bit_depth;
+- png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
+- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+- png_ptr->row_info.width);
+-
+- if (png_ptr->row_buf[0])
+- png_read_filter_row(png_ptr, &(png_ptr->row_info),
+- png_ptr->row_buf + 1, png_ptr->prev_row + 1,
+- (int)(png_ptr->row_buf[0]));
+-
+- png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
++ if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
++ png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
++ png_ptr->prev_row + 1, png_ptr->row_buf[0]);
++ else
++ png_error(png_ptr, "bad adaptive filter value");
++ }
++
++ /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
++ * 1.5.6, while the buffer really is this big in current versions of libpng
++ * it may not be in the future, so this was changed just to copy the
++ * interlaced count:
++ */
++ memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
+
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+- if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
++ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
+ (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
+ {
+ /* Intrapixel differencing */
+- png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
++ png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
+ }
+ #endif
+
+-
+ #ifdef PNG_READ_TRANSFORMS_SUPPORTED
+ if (png_ptr->transformations)
+- png_do_read_transformations(png_ptr);
++ png_do_read_transformations(png_ptr, &row_info);
+ #endif
+
++ /* The transformed pixel depth should match the depth now in row_info. */
++ if (png_ptr->transformed_pixel_depth == 0)
++ {
++ png_ptr->transformed_pixel_depth = row_info.pixel_depth;
++ if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
++ png_error(png_ptr, "sequential row overflow");
++ }
++
++ else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
++ png_error(png_ptr, "internal sequential row size calculation error");
++
+ #ifdef PNG_READ_INTERLACING_SUPPORTED
+- /* Blow up interlaced rows to full size */
+- if (png_ptr->interlaced &&
+- (png_ptr->transformations & PNG_INTERLACE))
++ /* Expand interlaced rows to full size */
++ if (png_ptr->interlaced != 0 &&
++ (png_ptr->transformations & PNG_INTERLACE) != 0)
+ {
+ if (png_ptr->pass < 6)
+- /* Old interface (pre-1.0.9):
+- * png_do_read_interlace(&(png_ptr->row_info),
+- * png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+- */
+- png_do_read_interlace(png_ptr);
++ png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
++ png_ptr->transformations);
+
+ if (dsp_row != NULL)
+- png_combine_row(png_ptr, dsp_row, png_pass_dsp_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, dsp_row, 1/*display*/);
+
+ if (row != NULL)
+- png_combine_row(png_ptr, row, png_pass_mask[png_ptr->pass]);
++ png_combine_row(png_ptr, row, 0/*row*/);
+ }
+
+ else
+ #endif
+ {
+ if (row != NULL)
+- png_combine_row(png_ptr, row, 0xff);
++ png_combine_row(png_ptr, row, -1/*ignored*/);
+
+ if (dsp_row != NULL)
+- png_combine_row(png_ptr, dsp_row, 0xff);
++ png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
+ }
+ png_read_finish_row(png_ptr);
+
+ if (png_ptr->read_row_fn != NULL)
+ (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
++
+ }
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
++#endif /* SEQUENTIAL_READ */
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read one or more rows of image data. If the image is interlaced,
+@@ -755,7 +661,7 @@
+ */
+
+ void PNGAPI
+-png_read_rows(png_structp png_ptr, png_bytepp row,
++png_read_rows(png_structrp png_ptr, png_bytepp row,
+ png_bytepp display_row, png_uint_32 num_rows)
+ {
+ png_uint_32 i;
+@@ -794,7 +700,7 @@
+ dp++;
+ }
+ }
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
++#endif /* SEQUENTIAL_READ */
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read the entire image. If the image has an alpha channel or a tRNS
+@@ -810,7 +716,7 @@
+ * [*] png_handle_alpha() does not exist yet, as of this version of libpng
+ */
+ void PNGAPI
+-png_read_image(png_structp png_ptr, png_bytepp image)
++png_read_image(png_structrp png_ptr, png_bytepp image)
+ {
+ png_uint_32 i, image_height;
+ int pass, j;
+@@ -822,7 +728,7 @@
+ return;
+
+ #ifdef PNG_READ_INTERLACING_SUPPORTED
+- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
++ if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
+ {
+ pass = png_set_interlace_handling(png_ptr);
+ /* And make sure transforms are initialized. */
+@@ -830,7 +736,8 @@
+ }
+ else
+ {
+- if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE))
++ if (png_ptr->interlaced != 0 &&
++ (png_ptr->transformations & PNG_INTERLACE) == 0)
+ {
+ /* Caller called png_start_read_image or png_read_update_info without
+ * first turning on the PNG_INTERLACE transform. We can fix this here,
+@@ -867,7 +774,7 @@
+ }
+ }
+ }
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
++#endif /* SEQUENTIAL_READ */
+
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ /* Read the end of the PNG file. Will not read past the end of the
+@@ -875,416 +782,261 @@
+ * or time information at the end of the file, if info is not NULL.
+ */
+ void PNGAPI
+-png_read_end(png_structp png_ptr, png_infop info_ptr)
++png_read_end(png_structrp png_ptr, png_inforp info_ptr)
+ {
++#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++ int keep;
++#endif
++
+ png_debug(1, "in png_read_end");
+
+ if (png_ptr == NULL)
+ return;
+
+- png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
++ /* If png_read_end is called in the middle of reading the rows there may
++ * still be pending IDAT data and an owned zstream. Deal with this here.
++ */
++#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++ if (png_chunk_unknown_handling(png_ptr, png_IDAT) == 0)
++#endif
++ png_read_finish_IDAT(png_ptr);
++
++#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
++ /* Report invalid palette index; added at libng-1.5.10 */
++ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
++ png_ptr->num_palette_max > png_ptr->num_palette)
++ png_benign_error(png_ptr, "Read palette index exceeding num_palette");
++#endif
+
+ do
+ {
+- PNG_IHDR;
+- PNG_IDAT;
+- PNG_IEND;
+- PNG_PLTE;
+-#ifdef PNG_READ_bKGD_SUPPORTED
+- PNG_bKGD;
+-#endif
+-#ifdef PNG_READ_cHRM_SUPPORTED
+- PNG_cHRM;
+-#endif
+-#ifdef PNG_READ_gAMA_SUPPORTED
+- PNG_gAMA;
+-#endif
+-#ifdef PNG_READ_hIST_SUPPORTED
+- PNG_hIST;
+-#endif
+-#ifdef PNG_READ_iCCP_SUPPORTED
+- PNG_iCCP;
+-#endif
+-#ifdef PNG_READ_iTXt_SUPPORTED
+- PNG_iTXt;
+-#endif
+-#ifdef PNG_READ_oFFs_SUPPORTED
+- PNG_oFFs;
+-#endif
+-#ifdef PNG_READ_pCAL_SUPPORTED
+- PNG_pCAL;
+-#endif
+-#ifdef PNG_READ_pHYs_SUPPORTED
+- PNG_pHYs;
+-#endif
+-#ifdef PNG_READ_sBIT_SUPPORTED
+- PNG_sBIT;
+-#endif
+-#ifdef PNG_READ_sCAL_SUPPORTED
+- PNG_sCAL;
+-#endif
+-#ifdef PNG_READ_sPLT_SUPPORTED
+- PNG_sPLT;
+-#endif
+-#ifdef PNG_READ_sRGB_SUPPORTED
+- PNG_sRGB;
+-#endif
+-#ifdef PNG_READ_tEXt_SUPPORTED
+- PNG_tEXt;
+-#endif
+-#ifdef PNG_READ_tIME_SUPPORTED
+- PNG_tIME;
+-#endif
+-#ifdef PNG_READ_tRNS_SUPPORTED
+- PNG_tRNS;
+-#endif
+-#ifdef PNG_READ_zTXt_SUPPORTED
+- PNG_zTXt;
+-#endif
+ png_uint_32 length = png_read_chunk_header(png_ptr);
+- PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;
+-
+- if (!png_memcmp(chunk_name, png_IHDR, 4))
++ png_uint_32 chunk_name = png_ptr->chunk_name;
++
++ if (chunk_name == png_IEND)
++ png_handle_IEND(png_ptr, info_ptr, length);
++
++ else if (chunk_name == png_IHDR)
+ png_handle_IHDR(png_ptr, info_ptr, length);
+
+- else if (!png_memcmp(chunk_name, png_IEND, 4))
+- png_handle_IEND(png_ptr, info_ptr, length);
++ else if (info_ptr == NULL)
++ png_crc_finish(png_ptr, length);
+
+ #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- else if (png_handle_as_unknown(png_ptr, chunk_name))
++ else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
+ {
+- if (!png_memcmp(chunk_name, png_IDAT, 4))
++ if (chunk_name == png_IDAT)
+ {
+- if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
++ if ((length > 0) ||
++ (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
+ png_benign_error(png_ptr, "Too many IDATs found");
+ }
+- png_handle_unknown(png_ptr, info_ptr, length);
+- if (!png_memcmp(chunk_name, png_PLTE, 4))
++ png_handle_unknown(png_ptr, info_ptr, length, keep);
++ if (chunk_name == png_PLTE)
+ png_ptr->mode |= PNG_HAVE_PLTE;
+ }
+ #endif
+
+- else if (!png_memcmp(chunk_name, png_IDAT, 4))
++ else if (chunk_name == png_IDAT)
+ {
+ /* Zero length IDATs are legal after the last IDAT has been
+ * read, but not after other chunks have been read.
+ */
+- if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
++ if ((length > 0) ||
++ (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
+ png_benign_error(png_ptr, "Too many IDATs found");
+
+ png_crc_finish(png_ptr, length);
+ }
+- else if (!png_memcmp(chunk_name, png_PLTE, 4))
++ else if (chunk_name == png_PLTE)
+ png_handle_PLTE(png_ptr, info_ptr, length);
+
+ #ifdef PNG_READ_bKGD_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_bKGD, 4))
++ else if (chunk_name == png_bKGD)
+ png_handle_bKGD(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_cHRM_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_cHRM, 4))
++ else if (chunk_name == png_cHRM)
+ png_handle_cHRM(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_gAMA_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_gAMA, 4))
++ else if (chunk_name == png_gAMA)
+ png_handle_gAMA(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_hIST_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_hIST, 4))
++ else if (chunk_name == png_hIST)
+ png_handle_hIST(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_oFFs_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_oFFs, 4))
++ else if (chunk_name == png_oFFs)
+ png_handle_oFFs(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_pCAL_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_pCAL, 4))
++ else if (chunk_name == png_pCAL)
+ png_handle_pCAL(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sCAL_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sCAL, 4))
++ else if (chunk_name == png_sCAL)
+ png_handle_sCAL(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_pHYs_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_pHYs, 4))
++ else if (chunk_name == png_pHYs)
+ png_handle_pHYs(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sBIT_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sBIT, 4))
++ else if (chunk_name == png_sBIT)
+ png_handle_sBIT(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sRGB_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sRGB, 4))
++ else if (chunk_name == png_sRGB)
+ png_handle_sRGB(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_iCCP_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_iCCP, 4))
++ else if (chunk_name == png_iCCP)
+ png_handle_iCCP(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_sPLT_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_sPLT, 4))
++ else if (chunk_name == png_sPLT)
+ png_handle_sPLT(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_tEXt_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_tEXt, 4))
++ else if (chunk_name == png_tEXt)
+ png_handle_tEXt(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_tIME_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_tIME, 4))
++ else if (chunk_name == png_tIME)
+ png_handle_tIME(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_tRNS_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_tRNS, 4))
++ else if (chunk_name == png_tRNS)
+ png_handle_tRNS(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_zTXt_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_zTXt, 4))
++ else if (chunk_name == png_zTXt)
+ png_handle_zTXt(png_ptr, info_ptr, length);
+ #endif
+
+ #ifdef PNG_READ_iTXt_SUPPORTED
+- else if (!png_memcmp(chunk_name, png_iTXt, 4))
++ else if (chunk_name == png_iTXt)
+ png_handle_iTXt(png_ptr, info_ptr, length);
+ #endif
+
+ else
+- png_handle_unknown(png_ptr, info_ptr, length);
+- } while (!(png_ptr->mode & PNG_HAVE_IEND));
++ png_handle_unknown(png_ptr, info_ptr, length,
++ PNG_HANDLE_CHUNK_AS_DEFAULT);
++ } while ((png_ptr->mode & PNG_HAVE_IEND) == 0);
+ }
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
++#endif /* SEQUENTIAL_READ */
++
++/* Free all memory used in the read struct */
++static void
++png_read_destroy(png_structrp png_ptr)
++{
++ png_debug(1, "in png_read_destroy");
++
++#ifdef PNG_READ_GAMMA_SUPPORTED
++ png_destroy_gamma_table(png_ptr);
++#endif
++
++ png_free(png_ptr, png_ptr->big_row_buf);
++ png_ptr->big_row_buf = NULL;
++ png_free(png_ptr, png_ptr->big_prev_row);
++ png_ptr->big_prev_row = NULL;
++ png_free(png_ptr, png_ptr->read_buffer);
++ png_ptr->read_buffer = NULL;
++
++#ifdef PNG_READ_QUANTIZE_SUPPORTED
++ png_free(png_ptr, png_ptr->palette_lookup);
++ png_ptr->palette_lookup = NULL;
++ png_free(png_ptr, png_ptr->quantize_index);
++ png_ptr->quantize_index = NULL;
++#endif
++
++ if ((png_ptr->free_me & PNG_FREE_PLTE) != 0)
++ {
++ png_zfree(png_ptr, png_ptr->palette);
++ png_ptr->palette = NULL;
++ }
++ png_ptr->free_me &= ~PNG_FREE_PLTE;
++
++#if defined(PNG_tRNS_SUPPORTED) || \
++ defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
++ if ((png_ptr->free_me & PNG_FREE_TRNS) != 0)
++ {
++ png_free(png_ptr, png_ptr->trans_alpha);
++ png_ptr->trans_alpha = NULL;
++ }
++ png_ptr->free_me &= ~PNG_FREE_TRNS;
++#endif
++
++ inflateEnd(&png_ptr->zstream);
++
++#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
++ png_free(png_ptr, png_ptr->save_buffer);
++ png_ptr->save_buffer = NULL;
++#endif
++
++#if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) && \
++ defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
++ png_free(png_ptr, png_ptr->unknown_chunk.data);
++ png_ptr->unknown_chunk.data = NULL;
++#endif
++
++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++ png_free(png_ptr, png_ptr->chunk_list);
++ png_ptr->chunk_list = NULL;
++#endif
++
++ /* NOTE: the 'setjmp' buffer may still be allocated and the memory and error
++ * callbacks are still set at this point. They are required to complete the
++ * destruction of the png_struct itself.
++ */
++}
+
+ /* Free all memory used by the read */
+ void PNGAPI
+ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
+ png_infopp end_info_ptr_ptr)
+ {
+- png_structp png_ptr = NULL;
+- png_infop info_ptr = NULL, end_info_ptr = NULL;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_free_ptr free_fn = NULL;
+- png_voidp mem_ptr = NULL;
+-#endif
++ png_structrp png_ptr = NULL;
+
+ png_debug(1, "in png_destroy_read_struct");
+
+ if (png_ptr_ptr != NULL)
+ png_ptr = *png_ptr_ptr;
++
+ if (png_ptr == NULL)
+ return;
+
+-#ifdef PNG_USER_MEM_SUPPORTED
+- free_fn = png_ptr->free_fn;
+- mem_ptr = png_ptr->mem_ptr;
+-#endif
+-
+- if (info_ptr_ptr != NULL)
+- info_ptr = *info_ptr_ptr;
+-
+- if (end_info_ptr_ptr != NULL)
+- end_info_ptr = *end_info_ptr_ptr;
+-
+- png_read_destroy(png_ptr, info_ptr, end_info_ptr);
+-
+- if (info_ptr != NULL)
+- {
+-#ifdef PNG_TEXT_SUPPORTED
+- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
+-#endif
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
+- (png_voidp)mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)info_ptr);
+-#endif
+- *info_ptr_ptr = NULL;
+- }
+-
+- if (end_info_ptr != NULL)
+- {
+-#ifdef PNG_READ_TEXT_SUPPORTED
+- png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
+-#endif
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
+- (png_voidp)mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)end_info_ptr);
+-#endif
+- *end_info_ptr_ptr = NULL;
+- }
+-
+- if (png_ptr != NULL)
+- {
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
+- (png_voidp)mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)png_ptr);
+-#endif
+- *png_ptr_ptr = NULL;
+- }
++ /* libpng 1.6.0: use the API to destroy info structs to ensure consistent
++ * behavior. Prior to 1.6.0 libpng did extra 'info' destruction in this API.
++ * The extra was, apparently, unnecessary yet this hides memory leak bugs.
++ */
++ png_destroy_info_struct(png_ptr, end_info_ptr_ptr);
++ png_destroy_info_struct(png_ptr, info_ptr_ptr);
++
++ *png_ptr_ptr = NULL;
++ png_read_destroy(png_ptr);
++ png_destroy_png_struct(png_ptr);
+ }
+
+-/* Free all memory used by the read (old method) */
+-void /* PRIVATE */
+-png_read_destroy(png_structp png_ptr, png_infop info_ptr,
+- png_infop end_info_ptr)
+-{
+-#ifdef PNG_SETJMP_SUPPORTED
+- jmp_buf tmp_jmp;
+-#endif
+- png_error_ptr error_fn;
+-#ifdef PNG_WARNINGS_SUPPORTED
+- png_error_ptr warning_fn;
+-#endif
+- png_voidp error_ptr;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_free_ptr free_fn;
+-#endif
+-
+- png_debug(1, "in png_read_destroy");
+-
+- if (info_ptr != NULL)
+- png_info_destroy(png_ptr, info_ptr);
+-
+- if (end_info_ptr != NULL)
+- png_info_destroy(png_ptr, end_info_ptr);
+-
+- png_free(png_ptr, png_ptr->zbuf);
+- png_free(png_ptr, png_ptr->big_row_buf);
+- png_free(png_ptr, png_ptr->prev_row);
+- png_free(png_ptr, png_ptr->chunkdata);
+-
+-#ifdef PNG_READ_QUANTIZE_SUPPORTED
+- png_free(png_ptr, png_ptr->palette_lookup);
+- png_free(png_ptr, png_ptr->quantize_index);
+-#endif
+-
+-#ifdef PNG_READ_GAMMA_SUPPORTED
+- png_free(png_ptr, png_ptr->gamma_table);
+-#endif
+-
+-#ifdef PNG_READ_BACKGROUND_SUPPORTED
+- png_free(png_ptr, png_ptr->gamma_from_1);
+- png_free(png_ptr, png_ptr->gamma_to_1);
+-#endif
+-
+- if (png_ptr->free_me & PNG_FREE_PLTE)
+- png_zfree(png_ptr, png_ptr->palette);
+- png_ptr->free_me &= ~PNG_FREE_PLTE;
+-
+-#if defined(PNG_tRNS_SUPPORTED) || \
+- defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+- if (png_ptr->free_me & PNG_FREE_TRNS)
+- png_free(png_ptr, png_ptr->trans_alpha);
+- png_ptr->free_me &= ~PNG_FREE_TRNS;
+-#endif
+-
+-#ifdef PNG_READ_hIST_SUPPORTED
+- if (png_ptr->free_me & PNG_FREE_HIST)
+- png_free(png_ptr, png_ptr->hist);
+- png_ptr->free_me &= ~PNG_FREE_HIST;
+-#endif
+-
+-#ifdef PNG_READ_GAMMA_SUPPORTED
+- if (png_ptr->gamma_16_table != NULL)
+- {
+- int i;
+- int istop = (1 << (8 - png_ptr->gamma_shift));
+- for (i = 0; i < istop; i++)
+- {
+- png_free(png_ptr, png_ptr->gamma_16_table[i]);
+- }
+- png_free(png_ptr, png_ptr->gamma_16_table);
+- }
+-
+-#ifdef PNG_READ_BACKGROUND_SUPPORTED
+- if (png_ptr->gamma_16_from_1 != NULL)
+- {
+- int i;
+- int istop = (1 << (8 - png_ptr->gamma_shift));
+- for (i = 0; i < istop; i++)
+- {
+- png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
+- }
+- png_free(png_ptr, png_ptr->gamma_16_from_1);
+- }
+- if (png_ptr->gamma_16_to_1 != NULL)
+- {
+- int i;
+- int istop = (1 << (8 - png_ptr->gamma_shift));
+- for (i = 0; i < istop; i++)
+- {
+- png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
+- }
+- png_free(png_ptr, png_ptr->gamma_16_to_1);
+- }
+-#endif
+-#endif
+-
+- inflateEnd(&png_ptr->zstream);
+-
+-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+- png_free(png_ptr, png_ptr->save_buffer);
+-#endif
+-
+-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+-#ifdef PNG_TEXT_SUPPORTED
+- png_free(png_ptr, png_ptr->current_text);
+-#endif /* PNG_TEXT_SUPPORTED */
+-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+-
+- /* Save the important info out of the png_struct, in case it is
+- * being used again.
+- */
+-#ifdef PNG_SETJMP_SUPPORTED
+- png_memcpy(tmp_jmp, png_ptr->longjmp_buffer, png_sizeof(jmp_buf));
+-#endif
+-
+- error_fn = png_ptr->error_fn;
+-#ifdef PNG_WARNINGS_SUPPORTED
+- warning_fn = png_ptr->warning_fn;
+-#endif
+- error_ptr = png_ptr->error_ptr;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- free_fn = png_ptr->free_fn;
+-#endif
+-
+- png_memset(png_ptr, 0, png_sizeof(png_struct));
+-
+- png_ptr->error_fn = error_fn;
+-#ifdef PNG_WARNINGS_SUPPORTED
+- png_ptr->warning_fn = warning_fn;
+-#endif
+- png_ptr->error_ptr = error_ptr;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_ptr->free_fn = free_fn;
+-#endif
+-
+-#ifdef PNG_SETJMP_SUPPORTED
+- png_memcpy(png_ptr->longjmp_buffer, tmp_jmp, png_sizeof(jmp_buf));
+-#endif
+-
+-}
+-
+ void PNGAPI
+-png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
++png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
+ {
+ if (png_ptr == NULL)
+ return;
+@@ -1296,12 +1048,10 @@
+ #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ #ifdef PNG_INFO_IMAGE_SUPPORTED
+ void PNGAPI
+-png_read_png(png_structp png_ptr, png_infop info_ptr,
++png_read_png(png_structrp png_ptr, png_inforp info_ptr,
+ int transforms,
+ voidp params)
+ {
+- int row;
+-
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+@@ -1309,130 +1059,153 @@
+ * PNG file before the first IDAT (image data chunk).
+ */
+ png_read_info(png_ptr, info_ptr);
+- if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
++ if (info_ptr->height > PNG_UINT_32_MAX/(sizeof (png_bytep)))
+ png_error(png_ptr, "Image is too high to process with png_read_png()");
+
+ /* -------------- image transformations start here ------------------- */
+-
+-#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
++ /* libpng 1.6.10: add code to cause a png_app_error if a selected TRANSFORM
++ * is not implemented. This will only happen in de-configured (non-default)
++ * libpng builds. The results can be unexpected - png_read_png may return
++ * short or mal-formed rows because the transform is skipped.
++ */
++
+ /* Tell libpng to strip 16-bit/color files down to 8 bits per color.
+ */
+- if (transforms & PNG_TRANSFORM_SCALE_16)
+- {
++ if ((transforms & PNG_TRANSFORM_SCALE_16) != 0)
+ /* Added at libpng-1.5.4. "strip_16" produces the same result that it
+ * did in earlier versions, while "scale_16" is now more accurate.
+ */
++#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+ png_set_scale_16(png_ptr);
+- }
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_SCALE_16 not supported");
+ #endif
+
+-#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+ /* If both SCALE and STRIP are required pngrtran will effectively cancel the
+ * latter by doing SCALE first. This is ok and allows apps not to check for
+ * which is supported to get the right answer.
+ */
+- if (transforms & PNG_TRANSFORM_STRIP_16)
++ if ((transforms & PNG_TRANSFORM_STRIP_16) != 0)
++#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+ png_set_strip_16(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_16 not supported");
+ #endif
+
+-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+ /* Strip alpha bytes from the input data without combining with
+ * the background (not recommended).
+ */
+- if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
++ if ((transforms & PNG_TRANSFORM_STRIP_ALPHA) != 0)
++#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+ png_set_strip_alpha(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_ALPHA not supported");
+ #endif
+
+-#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
+ /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
+ * byte into separate bytes (useful for paletted and grayscale images).
+ */
+- if (transforms & PNG_TRANSFORM_PACKING)
++ if ((transforms & PNG_TRANSFORM_PACKING) != 0)
++#ifdef PNG_READ_PACK_SUPPORTED
+ png_set_packing(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
+ #endif
+
+-#ifdef PNG_READ_PACKSWAP_SUPPORTED
+ /* Change the order of packed pixels to least significant bit first
+ * (not useful if you are using png_set_packing).
+ */
+- if (transforms & PNG_TRANSFORM_PACKSWAP)
++ if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0)
++#ifdef PNG_READ_PACKSWAP_SUPPORTED
+ png_set_packswap(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
+ #endif
+
+-#ifdef PNG_READ_EXPAND_SUPPORTED
+ /* Expand paletted colors into true RGB triplets
+ * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel
+ * Expand paletted or RGB images with transparency to full alpha
+ * channels so the data will be available as RGBA quartets.
+ */
+- if (transforms & PNG_TRANSFORM_EXPAND)
+- if ((png_ptr->bit_depth < 8) ||
+- (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
+- (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
+- png_set_expand(png_ptr);
++ if ((transforms & PNG_TRANSFORM_EXPAND) != 0)
++#ifdef PNG_READ_EXPAND_SUPPORTED
++ png_set_expand(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND not supported");
+ #endif
+
+ /* We don't handle background color or gamma transformation or quantizing.
+ */
+
+-#ifdef PNG_READ_INVERT_SUPPORTED
+ /* Invert monochrome files to have 0 as white and 1 as black
+ */
+- if (transforms & PNG_TRANSFORM_INVERT_MONO)
++ if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0)
++#ifdef PNG_READ_INVERT_SUPPORTED
+ png_set_invert_mono(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
+ #endif
+
+-#ifdef PNG_READ_SHIFT_SUPPORTED
+ /* If you want to shift the pixel values from the range [0,255] or
+ * [0,65535] to the original [0,7] or [0,31], or whatever range the
+ * colors were originally in:
+ */
+- if ((transforms & PNG_TRANSFORM_SHIFT)
+- && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
+- {
+- png_color_8p sig_bit;
+-
+- png_get_sBIT(png_ptr, info_ptr, &sig_bit);
+- png_set_shift(png_ptr, sig_bit);
+- }
++ if ((transforms & PNG_TRANSFORM_SHIFT) != 0)
++#ifdef PNG_READ_SHIFT_SUPPORTED
++ if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
++ png_set_shift(png_ptr, &info_ptr->sig_bit);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
+ #endif
+
++ /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
++ if ((transforms & PNG_TRANSFORM_BGR) != 0)
+ #ifdef PNG_READ_BGR_SUPPORTED
+- /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
+- if (transforms & PNG_TRANSFORM_BGR)
+ png_set_bgr(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
+ #endif
+
++ /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
++ if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0)
+ #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+- /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
+- if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
+ png_set_swap_alpha(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
+ #endif
+
++ /* Swap bytes of 16-bit files to least significant byte first */
++ if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0)
+ #ifdef PNG_READ_SWAP_SUPPORTED
+- /* Swap bytes of 16-bit files to least significant byte first */
+- if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
+ png_set_swap(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
+ #endif
+
+ /* Added at libpng-1.2.41 */
++ /* Invert the alpha channel from opacity to transparency */
++ if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0)
+ #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+- /* Invert the alpha channel from opacity to transparency */
+- if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
+ png_set_invert_alpha(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
+ #endif
+
+ /* Added at libpng-1.2.41 */
++ /* Expand grayscale image to RGB */
++ if ((transforms & PNG_TRANSFORM_GRAY_TO_RGB) != 0)
+ #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+- /* Expand grayscale image to RGB */
+- if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)
+ png_set_gray_to_rgb(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_GRAY_TO_RGB not supported");
+ #endif
+
+ /* Added at libpng-1.5.4 */
++ if ((transforms & PNG_TRANSFORM_EXPAND_16) != 0)
+ #ifdef PNG_READ_EXPAND_16_SUPPORTED
+- if (transforms & PNG_TRANSFORM_EXPAND_16)
+ png_set_expand_16(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND_16 not supported");
+ #endif
+
+ /* We don't handle adding filler bytes */
+@@ -1455,16 +1228,17 @@
+ {
+ png_uint_32 iptr;
+
+- info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
+- info_ptr->height * png_sizeof(png_bytep));
++ info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr,
++ info_ptr->height * (sizeof (png_bytep))));
++
+ for (iptr=0; iptr<info_ptr->height; iptr++)
+ info_ptr->row_pointers[iptr] = NULL;
+
+ info_ptr->free_me |= PNG_FREE_ROWS;
+
+- for (row = 0; row < (int)info_ptr->height; row++)
+- info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
+- png_get_rowbytes(png_ptr, info_ptr));
++ for (iptr = 0; iptr < info_ptr->height; iptr++)
++ info_ptr->row_pointers[iptr] = png_voidcast(png_bytep,
++ png_malloc(png_ptr, info_ptr->rowbytes));
+ }
+
+ png_read_image(png_ptr, info_ptr->row_pointers);
+@@ -1473,10 +1247,2903 @@
+ /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
+ png_read_end(png_ptr, info_ptr);
+
+- PNG_UNUSED(transforms) /* Quiet compiler warnings */
+ PNG_UNUSED(params)
+-
+ }
+-#endif /* PNG_INFO_IMAGE_SUPPORTED */
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
+-#endif /* PNG_READ_SUPPORTED */
++#endif /* INFO_IMAGE */
++#endif /* SEQUENTIAL_READ */
++
++#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
++/* SIMPLIFIED READ
++ *
++ * This code currently relies on the sequential reader, though it could easily
++ * be made to work with the progressive one.
++ */
++/* Arguments to png_image_finish_read: */
++
++/* Encoding of PNG data (used by the color-map code) */
++# define P_NOTSET 0 /* File encoding not yet known */
++# define P_sRGB 1 /* 8-bit encoded to sRGB gamma */
++# define P_LINEAR 2 /* 16-bit linear: not encoded, NOT pre-multiplied! */
++# define P_FILE 3 /* 8-bit encoded to file gamma, not sRGB or linear */
++# define P_LINEAR8 4 /* 8-bit linear: only from a file value */
++
++/* Color-map processing: after libpng has run on the PNG image further
++ * processing may be needed to convert the data to color-map indices.
++ */
++#define PNG_CMAP_NONE 0
++#define PNG_CMAP_GA 1 /* Process GA data to a color-map with alpha */
++#define PNG_CMAP_TRANS 2 /* Process GA data to a background index */
++#define PNG_CMAP_RGB 3 /* Process RGB data */
++#define PNG_CMAP_RGB_ALPHA 4 /* Process RGBA data */
++
++/* The following document where the background is for each processing case. */
++#define PNG_CMAP_NONE_BACKGROUND 256
++#define PNG_CMAP_GA_BACKGROUND 231
++#define PNG_CMAP_TRANS_BACKGROUND 254
++#define PNG_CMAP_RGB_BACKGROUND 256
++#define PNG_CMAP_RGB_ALPHA_BACKGROUND 216
++
++typedef struct
++{
++ /* Arguments: */
++ png_imagep image;
++ png_voidp buffer;
++ png_int_32 row_stride;
++ png_voidp colormap;
++ png_const_colorp background;
++ /* Local variables: */
++ png_voidp local_row;
++ png_voidp first_row;
++ ptrdiff_t row_bytes; /* step between rows */
++ int file_encoding; /* E_ values above */
++ png_fixed_point gamma_to_linear; /* For P_FILE, reciprocal of gamma */
++ int colormap_processing; /* PNG_CMAP_ values above */
++} png_image_read_control;
++
++/* Do all the *safe* initialization - 'safe' means that png_error won't be
++ * called, so setting up the jmp_buf is not required. This means that anything
++ * called from here must *not* call png_malloc - it has to call png_malloc_warn
++ * instead so that control is returned safely back to this routine.
++ */
++static int
++png_image_read_init(png_imagep image)
++{
++ if (image->opaque == NULL)
++ {
++ png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image,
++ png_safe_error, png_safe_warning);
++
++ /* And set the rest of the structure to NULL to ensure that the various
++ * fields are consistent.
++ */
++ memset(image, 0, (sizeof *image));
++ image->version = PNG_IMAGE_VERSION;
++
++ if (png_ptr != NULL)
++ {
++ png_infop info_ptr = png_create_info_struct(png_ptr);
++
++ if (info_ptr != NULL)
++ {
++ png_controlp control = png_voidcast(png_controlp,
++ png_malloc_warn(png_ptr, (sizeof *control)));
++
++ if (control != NULL)
++ {
++ memset(control, 0, (sizeof *control));
++
++ control->png_ptr = png_ptr;
++ control->info_ptr = info_ptr;
++ control->for_write = 0;
++
++ image->opaque = control;
++ return 1;
++ }
++
++ /* Error clean up */
++ png_destroy_info_struct(png_ptr, &info_ptr);
++ }
++
++ png_destroy_read_struct(&png_ptr, NULL, NULL);
++ }
++
++ return png_image_error(image, "png_image_read: out of memory");
++ }
++
++ return png_image_error(image, "png_image_read: opaque pointer not NULL");
++}
++
++/* Utility to find the base format of a PNG file from a png_struct. */
++static png_uint_32
++png_image_format(png_structrp png_ptr)
++{
++ png_uint_32 format = 0;
++
++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
++ format |= PNG_FORMAT_FLAG_COLOR;
++
++ if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
++ format |= PNG_FORMAT_FLAG_ALPHA;
++
++ /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS
++ * sets the png_struct fields; that's all we are interested in here. The
++ * precise interaction with an app call to png_set_tRNS and PNG file reading
++ * is unclear.
++ */
++ else if (png_ptr->num_trans > 0)
++ format |= PNG_FORMAT_FLAG_ALPHA;
++
++ if (png_ptr->bit_depth == 16)
++ format |= PNG_FORMAT_FLAG_LINEAR;
++
++ if ((png_ptr->color_type & PNG_COLOR_MASK_PALETTE) != 0)
++ format |= PNG_FORMAT_FLAG_COLORMAP;
++
++ return format;
++}
++
++/* Is the given gamma significantly different from sRGB? The test is the same
++ * one used in pngrtran.c when deciding whether to do gamma correction. The
++ * arithmetic optimizes the division by using the fact that the inverse of the
++ * file sRGB gamma is 2.2
++ */
++static int
++png_gamma_not_sRGB(png_fixed_point g)
++{
++ if (g < PNG_FP_1)
++ {
++ /* An uninitialized gamma is assumed to be sRGB for the simplified API. */
++ if (g == 0)
++ return 0;
++
++ return png_gamma_significant((g * 11 + 2)/5 /* i.e. *2.2, rounded */);
++ }
++
++ return 1;
++}
++
++/* Do the main body of a 'png_image_begin_read' function; read the PNG file
++ * header and fill in all the information. This is executed in a safe context,
++ * unlike the init routine above.
++ */
++static int
++png_image_read_header(png_voidp argument)
++{
++ png_imagep image = png_voidcast(png_imagep, argument);
++ png_structrp png_ptr = image->opaque->png_ptr;
++ png_inforp info_ptr = image->opaque->info_ptr;
++
++ png_set_benign_errors(png_ptr, 1/*warn*/);
++ png_read_info(png_ptr, info_ptr);
++
++ /* Do this the fast way; just read directly out of png_struct. */
++ image->width = png_ptr->width;
++ image->height = png_ptr->height;
++
++ {
++ png_uint_32 format = png_image_format(png_ptr);
++
++ image->format = format;
++
++#ifdef PNG_COLORSPACE_SUPPORTED
++ /* Does the colorspace match sRGB? If there is no color endpoint
++ * (colorant) information assume yes, otherwise require the
++ * 'ENDPOINTS_MATCHP_sRGB' colorspace flag to have been set. If the
++ * colorspace has been determined to be invalid ignore it.
++ */
++ if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags
++ & (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB|
++ PNG_COLORSPACE_INVALID)) == PNG_COLORSPACE_HAVE_ENDPOINTS))
++ image->flags |= PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB;
++#endif
++ }
++
++ /* We need the maximum number of entries regardless of the format the
++ * application sets here.
++ */
++ {
++ png_uint_32 cmap_entries;
++
++ switch (png_ptr->color_type)
++ {
++ case PNG_COLOR_TYPE_GRAY:
++ cmap_entries = 1U << png_ptr->bit_depth;
++ break;
++
++ case PNG_COLOR_TYPE_PALETTE:
++ cmap_entries = png_ptr->num_palette;
++ break;
++
++ default:
++ cmap_entries = 256;
++ break;
++ }
++
++ if (cmap_entries > 256)
++ cmap_entries = 256;
++
++ image->colormap_entries = cmap_entries;
++ }
++
++ return 1;
++}
++
++#ifdef PNG_STDIO_SUPPORTED
++int PNGAPI
++png_image_begin_read_from_stdio(png_imagep image, FILE* file)
++{
++ if (image != NULL && image->version == PNG_IMAGE_VERSION)
++ {
++ if (file != NULL)
++ {
++ if (png_image_read_init(image) != 0)
++ {
++ /* This is slightly evil, but png_init_io doesn't do anything other
++ * than this and we haven't changed the standard IO functions so
++ * this saves a 'safe' function.
++ */
++ image->opaque->png_ptr->io_ptr = file;
++ return png_safe_execute(image, png_image_read_header, image);
++ }
++ }
++
++ else
++ return png_image_error(image,
++ "png_image_begin_read_from_stdio: invalid argument");
++ }
++
++ else if (image != NULL)
++ return png_image_error(image,
++ "png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION");
++
++ return 0;
++}
++
++int PNGAPI
++png_image_begin_read_from_file(png_imagep image, const char *file_name)
++{
++ if (image != NULL && image->version == PNG_IMAGE_VERSION)
++ {
++ if (file_name != NULL)
++ {
++ FILE *fp = fopen(file_name, "rb");
++
++ if (fp != NULL)
++ {
++ if (png_image_read_init(image) != 0)
++ {
++ image->opaque->png_ptr->io_ptr = fp;
++ image->opaque->owned_file = 1;
++ return png_safe_execute(image, png_image_read_header, image);
++ }
++
++ /* Clean up: just the opened file. */
++ (void)fclose(fp);
++ }
++
++ else
++ return png_image_error(image, strerror(errno));
++ }
++
++ else
++ return png_image_error(image,
++ "png_image_begin_read_from_file: invalid argument");
++ }
++
++ else if (image != NULL)
++ return png_image_error(image,
++ "png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION");
++
++ return 0;
++}
++#endif /* STDIO */
++
++static void PNGCBAPI
++png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
++{
++ if (png_ptr != NULL)
++ {
++ png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);
++ if (image != NULL)
++ {
++ png_controlp cp = image->opaque;
++ if (cp != NULL)
++ {
++ png_const_bytep memory = cp->memory;
++ png_size_t size = cp->size;
++
++ if (memory != NULL && size >= need)
++ {
++ memcpy(out, memory, need);
++ cp->memory = memory + need;
++ cp->size = size - need;
++ return;
++ }
++
++ png_error(png_ptr, "read beyond end of data");
++ }
++ }
++
++ png_error(png_ptr, "invalid memory read");
++ }
++}
++
++int PNGAPI png_image_begin_read_from_memory(png_imagep image,
++ png_const_voidp memory, png_size_t size)
++{
++ if (image != NULL && image->version == PNG_IMAGE_VERSION)
++ {
++ if (memory != NULL && size > 0)
++ {
++ if (png_image_read_init(image) != 0)
++ {
++ /* Now set the IO functions to read from the memory buffer and
++ * store it into io_ptr. Again do this in-place to avoid calling a
++ * libpng function that requires error handling.
++ */
++ image->opaque->memory = png_voidcast(png_const_bytep, memory);
++ image->opaque->size = size;
++ image->opaque->png_ptr->io_ptr = image;
++ image->opaque->png_ptr->read_data_fn = png_image_memory_read;
++
++ return png_safe_execute(image, png_image_read_header, image);
++ }
++ }
++
++ else
++ return png_image_error(image,
++ "png_image_begin_read_from_memory: invalid argument");
++ }
++
++ else if (image != NULL)
++ return png_image_error(image,
++ "png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION");
++
++ return 0;
++}
++
++/* Utility function to skip chunks that are not used by the simplified image
++ * read functions and an appropriate macro to call it.
++ */
++#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++static void
++png_image_skip_unused_chunks(png_structrp png_ptr)
++{
++ /* Prepare the reader to ignore all recognized chunks whose data will not
++ * be used, i.e., all chunks recognized by libpng except for those
++ * involved in basic image reading:
++ *
++ * IHDR, PLTE, IDAT, IEND
++ *
++ * Or image data handling:
++ *
++ * tRNS, bKGD, gAMA, cHRM, sRGB, [iCCP] and sBIT.
++ *
++ * This provides a small performance improvement and eliminates any
++ * potential vulnerability to security problems in the unused chunks.
++ *
++ * At present the iCCP chunk data isn't used, so iCCP chunk can be ignored
++ * too. This allows the simplified API to be compiled without iCCP support,
++ * however if the support is there the chunk is still checked to detect
++ * errors (which are unfortunately quite common.)
++ */
++ {
++ static PNG_CONST png_byte chunks_to_process[] = {
++ 98, 75, 71, 68, '\0', /* bKGD */
++ 99, 72, 82, 77, '\0', /* cHRM */
++ 103, 65, 77, 65, '\0', /* gAMA */
++# ifdef PNG_READ_iCCP_SUPPORTED
++ 105, 67, 67, 80, '\0', /* iCCP */
++# endif
++ 115, 66, 73, 84, '\0', /* sBIT */
++ 115, 82, 71, 66, '\0', /* sRGB */
++ };
++
++ /* Ignore unknown chunks and all other chunks except for the
++ * IHDR, PLTE, tRNS, IDAT, and IEND chunks.
++ */
++ png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,
++ NULL, -1);
++
++ /* But do not ignore image data handling chunks */
++ png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
++ chunks_to_process, (int)/*SAFE*/(sizeof chunks_to_process)/5);
++ }
++}
++
++# define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p)
++#else
++# define PNG_SKIP_CHUNKS(p) ((void)0)
++#endif /* HANDLE_AS_UNKNOWN */
++
++/* The following macro gives the exact rounded answer for all values in the
++ * range 0..255 (it actually divides by 51.2, but the rounding still generates
++ * the correct numbers 0..5
++ */
++#define PNG_DIV51(v8) (((v8) * 5 + 130) >> 8)
++
++/* Utility functions to make particular color-maps */
++static void
++set_file_encoding(png_image_read_control *display)
++{
++ png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
++ if (png_gamma_significant(g) != 0)
++ {
++ if (png_gamma_not_sRGB(g) != 0)
++ {
++ display->file_encoding = P_FILE;
++ display->gamma_to_linear = png_reciprocal(g);
++ }
++
++ else
++ display->file_encoding = P_sRGB;
++ }
++
++ else
++ display->file_encoding = P_LINEAR8;
++}
++
++static unsigned int
++decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding)
++{
++ if (encoding == P_FILE) /* double check */
++ encoding = display->file_encoding;
++
++ if (encoding == P_NOTSET) /* must be the file encoding */
++ {
++ set_file_encoding(display);
++ encoding = display->file_encoding;
++ }
++
++ switch (encoding)
++ {
++ case P_FILE:
++ value = png_gamma_16bit_correct(value*257, display->gamma_to_linear);
++ break;
++
++ case P_sRGB:
++ value = png_sRGB_table[value];
++ break;
++
++ case P_LINEAR:
++ break;
++
++ case P_LINEAR8:
++ value *= 257;
++ break;
++
++ default:
++ png_error(display->image->opaque->png_ptr,
++ "unexpected encoding (internal error)");
++ break;
++ }
++
++ return value;
++}
++
++static png_uint_32
++png_colormap_compose(png_image_read_control *display,
++ png_uint_32 foreground, int foreground_encoding, png_uint_32 alpha,
++ png_uint_32 background, int encoding)
++{
++ /* The file value is composed on the background, the background has the given
++ * encoding and so does the result, the file is encoded with P_FILE and the
++ * file and alpha are 8-bit values. The (output) encoding will always be
++ * P_LINEAR or P_sRGB.
++ */
++ png_uint_32 f = decode_gamma(display, foreground, foreground_encoding);
++ png_uint_32 b = decode_gamma(display, background, encoding);
++
++ /* The alpha is always an 8-bit value (it comes from the palette), the value
++ * scaled by 255 is what PNG_sRGB_FROM_LINEAR requires.
++ */
++ f = f * alpha + b * (255-alpha);
++
++ if (encoding == P_LINEAR)
++ {
++ /* Scale to 65535; divide by 255, approximately (in fact this is extremely
++ * accurate, it divides by 255.00000005937181414556, with no overflow.)
++ */
++ f *= 257; /* Now scaled by 65535 */
++ f += f >> 16;
++ f = (f+32768) >> 16;
++ }
++
++ else /* P_sRGB */
++ f = PNG_sRGB_FROM_LINEAR(f);
++
++ return f;
++}
++
++/* NOTE: P_LINEAR values to this routine must be 16-bit, but P_FILE values must
++ * be 8-bit.
++ */
++static void
++png_create_colormap_entry(png_image_read_control *display,
++ png_uint_32 ip, png_uint_32 red, png_uint_32 green, png_uint_32 blue,
++ png_uint_32 alpha, int encoding)
++{
++ png_imagep image = display->image;
++ const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
++ P_LINEAR : P_sRGB;
++ const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&
++ (red != green || green != blue);
++
++ if (ip > 255)
++ png_error(image->opaque->png_ptr, "color-map index out of range");
++
++ /* Update the cache with whether the file gamma is significantly different
++ * from sRGB.
++ */
++ if (encoding == P_FILE)
++ {
++ if (display->file_encoding == P_NOTSET)
++ set_file_encoding(display);
++
++ /* Note that the cached value may be P_FILE too, but if it is then the
++ * gamma_to_linear member has been set.
++ */
++ encoding = display->file_encoding;
++ }
++
++ if (encoding == P_FILE)
++ {
++ png_fixed_point g = display->gamma_to_linear;
++
++ red = png_gamma_16bit_correct(red*257, g);
++ green = png_gamma_16bit_correct(green*257, g);
++ blue = png_gamma_16bit_correct(blue*257, g);
++
++ if (convert_to_Y != 0 || output_encoding == P_LINEAR)
++ {
++ alpha *= 257;
++ encoding = P_LINEAR;
++ }
++
++ else
++ {
++ red = PNG_sRGB_FROM_LINEAR(red * 255);
++ green = PNG_sRGB_FROM_LINEAR(green * 255);
++ blue = PNG_sRGB_FROM_LINEAR(blue * 255);
++ encoding = P_sRGB;
++ }
++ }
++
++ else if (encoding == P_LINEAR8)
++ {
++ /* This encoding occurs quite frequently in test cases because PngSuite
++ * includes a gAMA 1.0 chunk with most images.
++ */
++ red *= 257;
++ green *= 257;
++ blue *= 257;
++ alpha *= 257;
++ encoding = P_LINEAR;
++ }
++
++ else if (encoding == P_sRGB &&
++ (convert_to_Y != 0 || output_encoding == P_LINEAR))
++ {
++ /* The values are 8-bit sRGB values, but must be converted to 16-bit
++ * linear.
++ */
++ red = png_sRGB_table[red];
++ green = png_sRGB_table[green];
++ blue = png_sRGB_table[blue];
++ alpha *= 257;
++ encoding = P_LINEAR;
++ }
++
++ /* This is set if the color isn't gray but the output is. */
++ if (encoding == P_LINEAR)
++ {
++ if (convert_to_Y != 0)
++ {
++ /* NOTE: these values are copied from png_do_rgb_to_gray */
++ png_uint_32 y = (png_uint_32)6968 * red + (png_uint_32)23434 * green +
++ (png_uint_32)2366 * blue;
++
++ if (output_encoding == P_LINEAR)
++ y = (y + 16384) >> 15;
++
++ else
++ {
++ /* y is scaled by 32768, we need it scaled by 255: */
++ y = (y + 128) >> 8;
++ y *= 255;
++ y = PNG_sRGB_FROM_LINEAR((y + 64) >> 7);
++ encoding = P_sRGB;
++ }
++
++ blue = red = green = y;
++ }
++
++ else if (output_encoding == P_sRGB)
++ {
++ red = PNG_sRGB_FROM_LINEAR(red * 255);
++ green = PNG_sRGB_FROM_LINEAR(green * 255);
++ blue = PNG_sRGB_FROM_LINEAR(blue * 255);
++ alpha = PNG_DIV257(alpha);
++ encoding = P_sRGB;
++ }
++ }
++
++ if (encoding != output_encoding)
++ png_error(image->opaque->png_ptr, "bad encoding (internal error)");
++
++ /* Store the value. */
++ {
++# ifdef PNG_FORMAT_AFIRST_SUPPORTED
++ const int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
++ (image->format & PNG_FORMAT_FLAG_ALPHA) != 0;
++# else
++# define afirst 0
++# endif
++# ifdef PNG_FORMAT_BGR_SUPPORTED
++ const int bgr = (image->format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
++# else
++# define bgr 0
++# endif
++
++ if (output_encoding == P_LINEAR)
++ {
++ png_uint_16p entry = png_voidcast(png_uint_16p, display->colormap);
++
++ entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format);
++
++ /* The linear 16-bit values must be pre-multiplied by the alpha channel
++ * value, if less than 65535 (this is, effectively, composite on black
++ * if the alpha channel is removed.)
++ */
++ switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))
++ {
++ case 4:
++ entry[afirst ? 0 : 3] = (png_uint_16)alpha;
++ /* FALL THROUGH */
++
++ case 3:
++ if (alpha < 65535)
++ {
++ if (alpha > 0)
++ {
++ blue = (blue * alpha + 32767U)/65535U;
++ green = (green * alpha + 32767U)/65535U;
++ red = (red * alpha + 32767U)/65535U;
++ }
++
++ else
++ red = green = blue = 0;
++ }
++ entry[afirst + (2 ^ bgr)] = (png_uint_16)blue;
++ entry[afirst + 1] = (png_uint_16)green;
++ entry[afirst + bgr] = (png_uint_16)red;
++ break;
++
++ case 2:
++ entry[1 ^ afirst] = (png_uint_16)alpha;
++ /* FALL THROUGH */
++
++ case 1:
++ if (alpha < 65535)
++ {
++ if (alpha > 0)
++ green = (green * alpha + 32767U)/65535U;
++
++ else
++ green = 0;
++ }
++ entry[afirst] = (png_uint_16)green;
++ break;
++
++ default:
++ break;
++ }
++ }
++
++ else /* output encoding is P_sRGB */
++ {
++ png_bytep entry = png_voidcast(png_bytep, display->colormap);
++
++ entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format);
++
++ switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))
++ {
++ case 4:
++ entry[afirst ? 0 : 3] = (png_byte)alpha;
++ case 3:
++ entry[afirst + (2 ^ bgr)] = (png_byte)blue;
++ entry[afirst + 1] = (png_byte)green;
++ entry[afirst + bgr] = (png_byte)red;
++ break;
++
++ case 2:
++ entry[1 ^ afirst] = (png_byte)alpha;
++ case 1:
++ entry[afirst] = (png_byte)green;
++ break;
++
++ default:
++ break;
++ }
++ }
++
++# ifdef afirst
++# undef afirst
++# endif
++# ifdef bgr
++# undef bgr
++# endif
++ }
++}
++
++static int
++make_gray_file_colormap(png_image_read_control *display)
++{
++ unsigned int i;
++
++ for (i=0; i<256; ++i)
++ png_create_colormap_entry(display, i, i, i, i, 255, P_FILE);
++
++ return i;
++}
++
++static int
++make_gray_colormap(png_image_read_control *display)
++{
++ unsigned int i;
++
++ for (i=0; i<256; ++i)
++ png_create_colormap_entry(display, i, i, i, i, 255, P_sRGB);
++
++ return i;
++}
++#define PNG_GRAY_COLORMAP_ENTRIES 256
++
++static int
++make_ga_colormap(png_image_read_control *display)
++{
++ unsigned int i, a;
++
++ /* Alpha is retained, the output will be a color-map with entries
++ * selected by six levels of alpha. One transparent entry, 6 gray
++ * levels for all the intermediate alpha values, leaving 230 entries
++ * for the opaque grays. The color-map entries are the six values
++ * [0..5]*51, the GA processing uses PNG_DIV51(value) to find the
++ * relevant entry.
++ *
++ * if (alpha > 229) // opaque
++ * {
++ * // The 231 entries are selected to make the math below work:
++ * base = 0;
++ * entry = (231 * gray + 128) >> 8;
++ * }
++ * else if (alpha < 26) // transparent
++ * {
++ * base = 231;
++ * entry = 0;
++ * }
++ * else // partially opaque
++ * {
++ * base = 226 + 6 * PNG_DIV51(alpha);
++ * entry = PNG_DIV51(gray);
++ * }
++ */
++ i = 0;
++ while (i < 231)
++ {
++ unsigned int gray = (i * 256 + 115) / 231;
++ png_create_colormap_entry(display, i++, gray, gray, gray, 255, P_sRGB);
++ }
++
++ /* 255 is used here for the component values for consistency with the code
++ * that undoes premultiplication in pngwrite.c.
++ */
++ png_create_colormap_entry(display, i++, 255, 255, 255, 0, P_sRGB);
++
++ for (a=1; a<5; ++a)
++ {
++ unsigned int g;
++
++ for (g=0; g<6; ++g)
++ png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51,
++ P_sRGB);
++ }
++
++ return i;
++}
++
++#define PNG_GA_COLORMAP_ENTRIES 256
++
++static int
++make_rgb_colormap(png_image_read_control *display)
++{
++ unsigned int i, r;
++
++ /* Build a 6x6x6 opaque RGB cube */
++ for (i=r=0; r<6; ++r)
++ {
++ unsigned int g;
++
++ for (g=0; g<6; ++g)
++ {
++ unsigned int b;
++
++ for (b=0; b<6; ++b)
++ png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255,
++ P_sRGB);
++ }
++ }
++
++ return i;
++}
++
++#define PNG_RGB_COLORMAP_ENTRIES 216
++
++/* Return a palette index to the above palette given three 8-bit sRGB values. */
++#define PNG_RGB_INDEX(r,g,b) \
++ ((png_byte)(6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b)))
++
++static int
++png_image_read_colormap(png_voidp argument)
++{
++ png_image_read_control *display =
++ png_voidcast(png_image_read_control*, argument);
++ const png_imagep image = display->image;
++
++ const png_structrp png_ptr = image->opaque->png_ptr;
++ const png_uint_32 output_format = image->format;
++ const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
++ P_LINEAR : P_sRGB;
++
++ unsigned int cmap_entries;
++ unsigned int output_processing; /* Output processing option */
++ unsigned int data_encoding = P_NOTSET; /* Encoding libpng must produce */
++
++ /* Background information; the background color and the index of this color
++ * in the color-map if it exists (else 256).
++ */
++ unsigned int background_index = 256;
++ png_uint_32 back_r, back_g, back_b;
++
++ /* Flags to accumulate things that need to be done to the input. */
++ int expand_tRNS = 0;
++
++ /* Exclude the NYI feature of compositing onto a color-mapped buffer; it is
++ * very difficult to do, the results look awful, and it is difficult to see
++ * what possible use it is because the application can't control the
++ * color-map.
++ */
++ if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 ||
++ png_ptr->num_trans > 0) /* alpha in input */ &&
++ ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) /* no alpha in output */)
++ {
++ if (output_encoding == P_LINEAR) /* compose on black */
++ back_b = back_g = back_r = 0;
++
++ else if (display->background == NULL /* no way to remove it */)
++ png_error(png_ptr,
++ "a background color must be supplied to remove alpha/transparency");
++
++ /* Get a copy of the background color (this avoids repeating the checks
++ * below.) The encoding is 8-bit sRGB or 16-bit linear, depending on the
++ * output format.
++ */
++ else
++ {
++ back_g = display->background->green;
++ if ((output_format & PNG_FORMAT_FLAG_COLOR) != 0)
++ {
++ back_r = display->background->red;
++ back_b = display->background->blue;
++ }
++ else
++ back_b = back_r = back_g;
++ }
++ }
++
++ else if (output_encoding == P_LINEAR)
++ back_b = back_r = back_g = 65535;
++
++ else
++ back_b = back_r = back_g = 255;
++
++ /* Default the input file gamma if required - this is necessary because
++ * libpng assumes that if no gamma information is present the data is in the
++ * output format, but the simplified API deduces the gamma from the input
++ * format.
++ */
++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0)
++ {
++ /* Do this directly, not using the png_colorspace functions, to ensure
++ * that it happens even if the colorspace is invalid (though probably if
++ * it is the setting will be ignored) Note that the same thing can be
++ * achieved at the application interface with png_set_gAMA.
++ */
++ if (png_ptr->bit_depth == 16 &&
++ (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0)
++ png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR;
++
++ else
++ png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE;
++
++ png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
++ }
++
++ /* Decide what to do based on the PNG color type of the input data. The
++ * utility function png_create_colormap_entry deals with most aspects of the
++ * output transformations; this code works out how to produce bytes of
++ * color-map entries from the original format.
++ */
++ switch (png_ptr->color_type)
++ {
++ case PNG_COLOR_TYPE_GRAY:
++ if (png_ptr->bit_depth <= 8)
++ {
++ /* There at most 256 colors in the output, regardless of
++ * transparency.
++ */
++ unsigned int step, i, val, trans = 256/*ignore*/, back_alpha = 0;
++
++ cmap_entries = 1U << png_ptr->bit_depth;
++ if (cmap_entries > image->colormap_entries)
++ png_error(png_ptr, "gray[8] color-map: too few entries");
++
++ step = 255 / (cmap_entries - 1);
++ output_processing = PNG_CMAP_NONE;
++
++ /* If there is a tRNS chunk then this either selects a transparent
++ * value or, if the output has no alpha, the background color.
++ */
++ if (png_ptr->num_trans > 0)
++ {
++ trans = png_ptr->trans_color.gray;
++
++ if ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0)
++ back_alpha = output_encoding == P_LINEAR ? 65535 : 255;
++ }
++
++ /* png_create_colormap_entry just takes an RGBA and writes the
++ * corresponding color-map entry using the format from 'image',
++ * including the required conversion to sRGB or linear as
++ * appropriate. The input values are always either sRGB (if the
++ * gamma correction flag is 0) or 0..255 scaled file encoded values
++ * (if the function must gamma correct them).
++ */
++ for (i=val=0; i<cmap_entries; ++i, val += step)
++ {
++ /* 'i' is a file value. While this will result in duplicated
++ * entries for 8-bit non-sRGB encoded files it is necessary to
++ * have non-gamma corrected values to do tRNS handling.
++ */
++ if (i != trans)
++ png_create_colormap_entry(display, i, val, val, val, 255,
++ P_FILE/*8-bit with file gamma*/);
++
++ /* Else this entry is transparent. The colors don't matter if
++ * there is an alpha channel (back_alpha == 0), but it does no
++ * harm to pass them in; the values are not set above so this
++ * passes in white.
++ *
++ * NOTE: this preserves the full precision of the application
++ * supplied background color when it is used.
++ */
++ else
++ png_create_colormap_entry(display, i, back_r, back_g, back_b,
++ back_alpha, output_encoding);
++ }
++
++ /* We need libpng to preserve the original encoding. */
++ data_encoding = P_FILE;
++
++ /* The rows from libpng, while technically gray values, are now also
++ * color-map indices; however, they may need to be expanded to 1
++ * byte per pixel. This is what png_set_packing does (i.e., it
++ * unpacks the bit values into bytes.)
++ */
++ if (png_ptr->bit_depth < 8)
++ png_set_packing(png_ptr);
++ }
++
++ else /* bit depth is 16 */
++ {
++ /* The 16-bit input values can be converted directly to 8-bit gamma
++ * encoded values; however, if a tRNS chunk is present 257 color-map
++ * entries are required. This means that the extra entry requires
++ * special processing; add an alpha channel, sacrifice gray level
++ * 254 and convert transparent (alpha==0) entries to that.
++ *
++ * Use libpng to chop the data to 8 bits. Convert it to sRGB at the
++ * same time to minimize quality loss. If a tRNS chunk is present
++ * this means libpng must handle it too; otherwise it is impossible
++ * to do the exact match on the 16-bit value.
++ *
++ * If the output has no alpha channel *and* the background color is
++ * gray then it is possible to let libpng handle the substitution by
++ * ensuring that the corresponding gray level matches the background
++ * color exactly.
++ */
++ data_encoding = P_sRGB;
++
++ if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)
++ png_error(png_ptr, "gray[16] color-map: too few entries");
++
++ cmap_entries = make_gray_colormap(display);
++
++ if (png_ptr->num_trans > 0)
++ {
++ unsigned int back_alpha;
++
++ if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ back_alpha = 0;
++
++ else
++ {
++ if (back_r == back_g && back_g == back_b)
++ {
++ /* Background is gray; no special processing will be
++ * required.
++ */
++ png_color_16 c;
++ png_uint_32 gray = back_g;
++
++ if (output_encoding == P_LINEAR)
++ {
++ gray = PNG_sRGB_FROM_LINEAR(gray * 255);
++
++ /* And make sure the corresponding palette entry
++ * matches.
++ */
++ png_create_colormap_entry(display, gray, back_g, back_g,
++ back_g, 65535, P_LINEAR);
++ }
++
++ /* The background passed to libpng, however, must be the
++ * sRGB value.
++ */
++ c.index = 0; /*unused*/
++ c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
++
++ /* NOTE: does this work without expanding tRNS to alpha?
++ * It should be the color->gray case below apparently
++ * doesn't.
++ */
++ png_set_background_fixed(png_ptr, &c,
++ PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
++ 0/*gamma: not used*/);
++
++ output_processing = PNG_CMAP_NONE;
++ break;
++ }
++
++ back_alpha = output_encoding == P_LINEAR ? 65535 : 255;
++ }
++
++ /* output_processing means that the libpng-processed row will be
++ * 8-bit GA and it has to be processing to single byte color-map
++ * values. Entry 254 is replaced by either a completely
++ * transparent entry or by the background color at full
++ * precision (and the background color is not a simple gray
++ * level in this case.)
++ */
++ expand_tRNS = 1;
++ output_processing = PNG_CMAP_TRANS;
++ background_index = 254;
++
++ /* And set (overwrite) color-map entry 254 to the actual
++ * background color at full precision.
++ */
++ png_create_colormap_entry(display, 254, back_r, back_g, back_b,
++ back_alpha, output_encoding);
++ }
++
++ else
++ output_processing = PNG_CMAP_NONE;
++ }
++ break;
++
++ case PNG_COLOR_TYPE_GRAY_ALPHA:
++ /* 8-bit or 16-bit PNG with two channels - gray and alpha. A minimum
++ * of 65536 combinations. If, however, the alpha channel is to be
++ * removed there are only 256 possibilities if the background is gray.
++ * (Otherwise there is a subset of the 65536 possibilities defined by
++ * the triangle between black, white and the background color.)
++ *
++ * Reduce 16-bit files to 8-bit and sRGB encode the result. No need to
++ * worry about tRNS matching - tRNS is ignored if there is an alpha
++ * channel.
++ */
++ data_encoding = P_sRGB;
++
++ if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++ if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)
++ png_error(png_ptr, "gray+alpha color-map: too few entries");
++
++ cmap_entries = make_ga_colormap(display);
++
++ background_index = PNG_CMAP_GA_BACKGROUND;
++ output_processing = PNG_CMAP_GA;
++ }
++
++ else /* alpha is removed */
++ {
++ /* Alpha must be removed as the PNG data is processed when the
++ * background is a color because the G and A channels are
++ * independent and the vector addition (non-parallel vectors) is a
++ * 2-D problem.
++ *
++ * This can be reduced to the same algorithm as above by making a
++ * colormap containing gray levels (for the opaque grays), a
++ * background entry (for a transparent pixel) and a set of four six
++ * level color values, one set for each intermediate alpha value.
++ * See the comments in make_ga_colormap for how this works in the
++ * per-pixel processing.
++ *
++ * If the background is gray, however, we only need a 256 entry gray
++ * level color map. It is sufficient to make the entry generated
++ * for the background color be exactly the color specified.
++ */
++ if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0 ||
++ (back_r == back_g && back_g == back_b))
++ {
++ /* Background is gray; no special processing will be required. */
++ png_color_16 c;
++ png_uint_32 gray = back_g;
++
++ if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)
++ png_error(png_ptr, "gray-alpha color-map: too few entries");
++
++ cmap_entries = make_gray_colormap(display);
++
++ if (output_encoding == P_LINEAR)
++ {
++ gray = PNG_sRGB_FROM_LINEAR(gray * 255);
++
++ /* And make sure the corresponding palette entry matches. */
++ png_create_colormap_entry(display, gray, back_g, back_g,
++ back_g, 65535, P_LINEAR);
++ }
++
++ /* The background passed to libpng, however, must be the sRGB
++ * value.
++ */
++ c.index = 0; /*unused*/
++ c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
++
++ png_set_background_fixed(png_ptr, &c,
++ PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
++ 0/*gamma: not used*/);
++
++ output_processing = PNG_CMAP_NONE;
++ }
++
++ else
++ {
++ png_uint_32 i, a;
++
++ /* This is the same as png_make_ga_colormap, above, except that
++ * the entries are all opaque.
++ */
++ if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)
++ png_error(png_ptr, "ga-alpha color-map: too few entries");
++
++ i = 0;
++ while (i < 231)
++ {
++ png_uint_32 gray = (i * 256 + 115) / 231;
++ png_create_colormap_entry(display, i++, gray, gray, gray,
++ 255, P_sRGB);
++ }
++
++ /* NOTE: this preserves the full precision of the application
++ * background color.
++ */
++ background_index = i;
++ png_create_colormap_entry(display, i++, back_r, back_g, back_b,
++ output_encoding == P_LINEAR ? 65535U : 255U, output_encoding);
++
++ /* For non-opaque input composite on the sRGB background - this
++ * requires inverting the encoding for each component. The input
++ * is still converted to the sRGB encoding because this is a
++ * reasonable approximate to the logarithmic curve of human
++ * visual sensitivity, at least over the narrow range which PNG
++ * represents. Consequently 'G' is always sRGB encoded, while
++ * 'A' is linear. We need the linear background colors.
++ */
++ if (output_encoding == P_sRGB) /* else already linear */
++ {
++ /* This may produce a value not exactly matching the
++ * background, but that's ok because these numbers are only
++ * used when alpha != 0
++ */
++ back_r = png_sRGB_table[back_r];
++ back_g = png_sRGB_table[back_g];
++ back_b = png_sRGB_table[back_b];
++ }
++
++ for (a=1; a<5; ++a)
++ {
++ unsigned int g;
++
++ /* PNG_sRGB_FROM_LINEAR expects a 16-bit linear value scaled
++ * by an 8-bit alpha value (0..255).
++ */
++ png_uint_32 alpha = 51 * a;
++ png_uint_32 back_rx = (255-alpha) * back_r;
++ png_uint_32 back_gx = (255-alpha) * back_g;
++ png_uint_32 back_bx = (255-alpha) * back_b;
++
++ for (g=0; g<6; ++g)
++ {
++ png_uint_32 gray = png_sRGB_table[g*51] * alpha;
++
++ png_create_colormap_entry(display, i++,
++ PNG_sRGB_FROM_LINEAR(gray + back_rx),
++ PNG_sRGB_FROM_LINEAR(gray + back_gx),
++ PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, P_sRGB);
++ }
++ }
++
++ cmap_entries = i;
++ output_processing = PNG_CMAP_GA;
++ }
++ }
++ break;
++
++ case PNG_COLOR_TYPE_RGB:
++ case PNG_COLOR_TYPE_RGB_ALPHA:
++ /* Exclude the case where the output is gray; we can always handle this
++ * with the cases above.
++ */
++ if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0)
++ {
++ /* The color-map will be grayscale, so we may as well convert the
++ * input RGB values to a simple grayscale and use the grayscale
++ * code above.
++ *
++ * NOTE: calling this apparently damages the recognition of the
++ * transparent color in background color handling; call
++ * png_set_tRNS_to_alpha before png_set_background_fixed.
++ */
++ png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,
++ -1);
++ data_encoding = P_sRGB;
++
++ /* The output will now be one or two 8-bit gray or gray+alpha
++ * channels. The more complex case arises when the input has alpha.
++ */
++ if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ png_ptr->num_trans > 0) &&
++ (output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++ /* Both input and output have an alpha channel, so no background
++ * processing is required; just map the GA bytes to the right
++ * color-map entry.
++ */
++ expand_tRNS = 1;
++
++ if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)
++ png_error(png_ptr, "rgb[ga] color-map: too few entries");
++
++ cmap_entries = make_ga_colormap(display);
++ background_index = PNG_CMAP_GA_BACKGROUND;
++ output_processing = PNG_CMAP_GA;
++ }
++
++ else
++ {
++ /* Either the input or the output has no alpha channel, so there
++ * will be no non-opaque pixels in the color-map; it will just be
++ * grayscale.
++ */
++ if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)
++ png_error(png_ptr, "rgb[gray] color-map: too few entries");
++
++ /* Ideally this code would use libpng to do the gamma correction,
++ * but if an input alpha channel is to be removed we will hit the
++ * libpng bug in gamma+compose+rgb-to-gray (the double gamma
++ * correction bug). Fix this by dropping the gamma correction in
++ * this case and doing it in the palette; this will result in
++ * duplicate palette entries, but that's better than the
++ * alternative of double gamma correction.
++ */
++ if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ png_ptr->num_trans > 0) &&
++ png_gamma_not_sRGB(png_ptr->colorspace.gamma) != 0)
++ {
++ cmap_entries = make_gray_file_colormap(display);
++ data_encoding = P_FILE;
++ }
++
++ else
++ cmap_entries = make_gray_colormap(display);
++
++ /* But if the input has alpha or transparency it must be removed
++ */
++ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ png_ptr->num_trans > 0)
++ {
++ png_color_16 c;
++ png_uint_32 gray = back_g;
++
++ /* We need to ensure that the application background exists in
++ * the colormap and that completely transparent pixels map to
++ * it. Achieve this simply by ensuring that the entry
++ * selected for the background really is the background color.
++ */
++ if (data_encoding == P_FILE) /* from the fixup above */
++ {
++ /* The app supplied a gray which is in output_encoding, we
++ * need to convert it to a value of the input (P_FILE)
++ * encoding then set this palette entry to the required
++ * output encoding.
++ */
++ if (output_encoding == P_sRGB)
++ gray = png_sRGB_table[gray]; /* now P_LINEAR */
++
++ gray = PNG_DIV257(png_gamma_16bit_correct(gray,
++ png_ptr->colorspace.gamma)); /* now P_FILE */
++
++ /* And make sure the corresponding palette entry contains
++ * exactly the required sRGB value.
++ */
++ png_create_colormap_entry(display, gray, back_g, back_g,
++ back_g, 0/*unused*/, output_encoding);
++ }
++
++ else if (output_encoding == P_LINEAR)
++ {
++ gray = PNG_sRGB_FROM_LINEAR(gray * 255);
++
++ /* And make sure the corresponding palette entry matches.
++ */
++ png_create_colormap_entry(display, gray, back_g, back_g,
++ back_g, 0/*unused*/, P_LINEAR);
++ }
++
++ /* The background passed to libpng, however, must be the
++ * output (normally sRGB) value.
++ */
++ c.index = 0; /*unused*/
++ c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
++
++ /* NOTE: the following is apparently a bug in libpng. Without
++ * it the transparent color recognition in
++ * png_set_background_fixed seems to go wrong.
++ */
++ expand_tRNS = 1;
++ png_set_background_fixed(png_ptr, &c,
++ PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
++ 0/*gamma: not used*/);
++ }
++
++ output_processing = PNG_CMAP_NONE;
++ }
++ }
++
++ else /* output is color */
++ {
++ /* We could use png_quantize here so long as there is no transparent
++ * color or alpha; png_quantize ignores alpha. Easier overall just
++ * to do it once and using PNG_DIV51 on the 6x6x6 reduced RGB cube.
++ * Consequently we always want libpng to produce sRGB data.
++ */
++ data_encoding = P_sRGB;
++
++ /* Is there any transparency or alpha? */
++ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ png_ptr->num_trans > 0)
++ {
++ /* Is there alpha in the output too? If so all four channels are
++ * processed into a special RGB cube with alpha support.
++ */
++ if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++ png_uint_32 r;
++
++ if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries)
++ png_error(png_ptr, "rgb+alpha color-map: too few entries");
++
++ cmap_entries = make_rgb_colormap(display);
++
++ /* Add a transparent entry. */
++ png_create_colormap_entry(display, cmap_entries, 255, 255,
++ 255, 0, P_sRGB);
++
++ /* This is stored as the background index for the processing
++ * algorithm.
++ */
++ background_index = cmap_entries++;
++
++ /* Add 27 r,g,b entries each with alpha 0.5. */
++ for (r=0; r<256; r = (r << 1) | 0x7f)
++ {
++ png_uint_32 g;
++
++ for (g=0; g<256; g = (g << 1) | 0x7f)
++ {
++ png_uint_32 b;
++
++ /* This generates components with the values 0, 127 and
++ * 255
++ */
++ for (b=0; b<256; b = (b << 1) | 0x7f)
++ png_create_colormap_entry(display, cmap_entries++,
++ r, g, b, 128, P_sRGB);
++ }
++ }
++
++ expand_tRNS = 1;
++ output_processing = PNG_CMAP_RGB_ALPHA;
++ }
++
++ else
++ {
++ /* Alpha/transparency must be removed. The background must
++ * exist in the color map (achieved by setting adding it after
++ * the 666 color-map). If the standard processing code will
++ * pick up this entry automatically that's all that is
++ * required; libpng can be called to do the background
++ * processing.
++ */
++ unsigned int sample_size =
++ PNG_IMAGE_SAMPLE_SIZE(output_format);
++ png_uint_32 r, g, b; /* sRGB background */
++
++ if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries)
++ png_error(png_ptr, "rgb-alpha color-map: too few entries");
++
++ cmap_entries = make_rgb_colormap(display);
++
++ png_create_colormap_entry(display, cmap_entries, back_r,
++ back_g, back_b, 0/*unused*/, output_encoding);
++
++ if (output_encoding == P_LINEAR)
++ {
++ r = PNG_sRGB_FROM_LINEAR(back_r * 255);
++ g = PNG_sRGB_FROM_LINEAR(back_g * 255);
++ b = PNG_sRGB_FROM_LINEAR(back_b * 255);
++ }
++
++ else
++ {
++ r = back_r;
++ g = back_g;
++ b = back_g;
++ }
++
++ /* Compare the newly-created color-map entry with the one the
++ * PNG_CMAP_RGB algorithm will use. If the two entries don't
++ * match, add the new one and set this as the background
++ * index.
++ */
++ if (memcmp((png_const_bytep)display->colormap +
++ sample_size * cmap_entries,
++ (png_const_bytep)display->colormap +
++ sample_size * PNG_RGB_INDEX(r,g,b),
++ sample_size) != 0)
++ {
++ /* The background color must be added. */
++ background_index = cmap_entries++;
++
++ /* Add 27 r,g,b entries each with created by composing with
++ * the background at alpha 0.5.
++ */
++ for (r=0; r<256; r = (r << 1) | 0x7f)
++ {
++ for (g=0; g<256; g = (g << 1) | 0x7f)
++ {
++ /* This generates components with the values 0, 127
++ * and 255
++ */
++ for (b=0; b<256; b = (b << 1) | 0x7f)
++ png_create_colormap_entry(display, cmap_entries++,
++ png_colormap_compose(display, r, P_sRGB, 128,
++ back_r, output_encoding),
++ png_colormap_compose(display, g, P_sRGB, 128,
++ back_g, output_encoding),
++ png_colormap_compose(display, b, P_sRGB, 128,
++ back_b, output_encoding),
++ 0/*unused*/, output_encoding);
++ }
++ }
++
++ expand_tRNS = 1;
++ output_processing = PNG_CMAP_RGB_ALPHA;
++ }
++
++ else /* background color is in the standard color-map */
++ {
++ png_color_16 c;
++
++ c.index = 0; /*unused*/
++ c.red = (png_uint_16)back_r;
++ c.gray = c.green = (png_uint_16)back_g;
++ c.blue = (png_uint_16)back_b;
++
++ png_set_background_fixed(png_ptr, &c,
++ PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
++ 0/*gamma: not used*/);
++
++ output_processing = PNG_CMAP_RGB;
++ }
++ }
++ }
++
++ else /* no alpha or transparency in the input */
++ {
++ /* Alpha in the output is irrelevant, simply map the opaque input
++ * pixels to the 6x6x6 color-map.
++ */
++ if (PNG_RGB_COLORMAP_ENTRIES > image->colormap_entries)
++ png_error(png_ptr, "rgb color-map: too few entries");
++
++ cmap_entries = make_rgb_colormap(display);
++ output_processing = PNG_CMAP_RGB;
++ }
++ }
++ break;
++
++ case PNG_COLOR_TYPE_PALETTE:
++ /* It's already got a color-map. It may be necessary to eliminate the
++ * tRNS entries though.
++ */
++ {
++ unsigned int num_trans = png_ptr->num_trans;
++ png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;
++ png_const_colorp colormap = png_ptr->palette;
++ const int do_background = trans != NULL &&
++ (output_format & PNG_FORMAT_FLAG_ALPHA) == 0;
++ unsigned int i;
++
++ /* Just in case: */
++ if (trans == NULL)
++ num_trans = 0;
++
++ output_processing = PNG_CMAP_NONE;
++ data_encoding = P_FILE; /* Don't change from color-map indices */
++ cmap_entries = png_ptr->num_palette;
++ if (cmap_entries > 256)
++ cmap_entries = 256;
++
++ if (cmap_entries > image->colormap_entries)
++ png_error(png_ptr, "palette color-map: too few entries");
++
++ for (i=0; i < cmap_entries; ++i)
++ {
++ if (do_background != 0 && i < num_trans && trans[i] < 255)
++ {
++ if (trans[i] == 0)
++ png_create_colormap_entry(display, i, back_r, back_g,
++ back_b, 0, output_encoding);
++
++ else
++ {
++ /* Must compose the PNG file color in the color-map entry
++ * on the sRGB color in 'back'.
++ */
++ png_create_colormap_entry(display, i,
++ png_colormap_compose(display, colormap[i].red, P_FILE,
++ trans[i], back_r, output_encoding),
++ png_colormap_compose(display, colormap[i].green, P_FILE,
++ trans[i], back_g, output_encoding),
++ png_colormap_compose(display, colormap[i].blue, P_FILE,
++ trans[i], back_b, output_encoding),
++ output_encoding == P_LINEAR ? trans[i] * 257U :
++ trans[i],
++ output_encoding);
++ }
++ }
++
++ else
++ png_create_colormap_entry(display, i, colormap[i].red,
++ colormap[i].green, colormap[i].blue,
++ i < num_trans ? trans[i] : 255U, P_FILE/*8-bit*/);
++ }
++
++ /* The PNG data may have indices packed in fewer than 8 bits, it
++ * must be expanded if so.
++ */
++ if (png_ptr->bit_depth < 8)
++ png_set_packing(png_ptr);
++ }
++ break;
++
++ default:
++ png_error(png_ptr, "invalid PNG color type");
++ /*NOT REACHED*/
++ break;
++ }
++
++ /* Now deal with the output processing */
++ if (expand_tRNS != 0 && png_ptr->num_trans > 0 &&
++ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)
++ png_set_tRNS_to_alpha(png_ptr);
++
++ switch (data_encoding)
++ {
++ default:
++ png_error(png_ptr, "bad data option (internal error)");
++ break;
++
++ case P_sRGB:
++ /* Change to 8-bit sRGB */
++ png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB);
++ /* FALL THROUGH */
++
++ case P_FILE:
++ if (png_ptr->bit_depth > 8)
++ png_set_scale_16(png_ptr);
++ break;
++ }
++
++ if (cmap_entries > 256 || cmap_entries > image->colormap_entries)
++ png_error(png_ptr, "color map overflow (BAD internal error)");
++
++ image->colormap_entries = cmap_entries;
++
++ /* Double check using the recorded background index */
++ switch (output_processing)
++ {
++ case PNG_CMAP_NONE:
++ if (background_index != PNG_CMAP_NONE_BACKGROUND)
++ goto bad_background;
++ break;
++
++ case PNG_CMAP_GA:
++ if (background_index != PNG_CMAP_GA_BACKGROUND)
++ goto bad_background;
++ break;
++
++ case PNG_CMAP_TRANS:
++ if (background_index >= cmap_entries ||
++ background_index != PNG_CMAP_TRANS_BACKGROUND)
++ goto bad_background;
++ break;
++
++ case PNG_CMAP_RGB:
++ if (background_index != PNG_CMAP_RGB_BACKGROUND)
++ goto bad_background;
++ break;
++
++ case PNG_CMAP_RGB_ALPHA:
++ if (background_index != PNG_CMAP_RGB_ALPHA_BACKGROUND)
++ goto bad_background;
++ break;
++
++ default:
++ png_error(png_ptr, "bad processing option (internal error)");
++
++ bad_background:
++ png_error(png_ptr, "bad background index (internal error)");
++ }
++
++ display->colormap_processing = output_processing;
++
++ return 1/*ok*/;
++}
++
++/* The final part of the color-map read called from png_image_finish_read. */
++static int
++png_image_read_and_map(png_voidp argument)
++{
++ png_image_read_control *display = png_voidcast(png_image_read_control*,
++ argument);
++ png_imagep image = display->image;
++ png_structrp png_ptr = image->opaque->png_ptr;
++ int passes;
++
++ /* Called when the libpng data must be transformed into the color-mapped
++ * form. There is a local row buffer in display->local and this routine must
++ * do the interlace handling.
++ */
++ switch (png_ptr->interlaced)
++ {
++ case PNG_INTERLACE_NONE:
++ passes = 1;
++ break;
++
++ case PNG_INTERLACE_ADAM7:
++ passes = PNG_INTERLACE_ADAM7_PASSES;
++ break;
++
++ default:
++ png_error(png_ptr, "unknown interlace type");
++ }
++
++ {
++ png_uint_32 height = image->height;
++ png_uint_32 width = image->width;
++ int proc = display->colormap_processing;
++ png_bytep first_row = png_voidcast(png_bytep, display->first_row);
++ ptrdiff_t step_row = display->row_bytes;
++ int pass;
++
++ for (pass = 0; pass < passes; ++pass)
++ {
++ unsigned int startx, stepx, stepy;
++ png_uint_32 y;
++
++ if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
++ {
++ /* The row may be empty for a short image: */
++ if (PNG_PASS_COLS(width, pass) == 0)
++ continue;
++
++ startx = PNG_PASS_START_COL(pass);
++ stepx = PNG_PASS_COL_OFFSET(pass);
++ y = PNG_PASS_START_ROW(pass);
++ stepy = PNG_PASS_ROW_OFFSET(pass);
++ }
++
++ else
++ {
++ y = 0;
++ startx = 0;
++ stepx = stepy = 1;
++ }
++
++ for (; y<height; y += stepy)
++ {
++ png_bytep inrow = png_voidcast(png_bytep, display->local_row);
++ png_bytep outrow = first_row + y * step_row;
++ png_const_bytep end_row = outrow + width;
++
++ /* Read read the libpng data into the temporary buffer. */
++ png_read_row(png_ptr, inrow, NULL);
++
++ /* Now process the row according to the processing option, note
++ * that the caller verifies that the format of the libpng output
++ * data is as required.
++ */
++ outrow += startx;
++ switch (proc)
++ {
++ case PNG_CMAP_GA:
++ for (; outrow < end_row; outrow += stepx)
++ {
++ /* The data is always in the PNG order */
++ unsigned int gray = *inrow++;
++ unsigned int alpha = *inrow++;
++ unsigned int entry;
++
++ /* NOTE: this code is copied as a comment in
++ * make_ga_colormap above. Please update the
++ * comment if you change this code!
++ */
++ if (alpha > 229) /* opaque */
++ {
++ entry = (231 * gray + 128) >> 8;
++ }
++ else if (alpha < 26) /* transparent */
++ {
++ entry = 231;
++ }
++ else /* partially opaque */
++ {
++ entry = 226 + 6 * PNG_DIV51(alpha) + PNG_DIV51(gray);
++ }
++
++ *outrow = (png_byte)entry;
++ }
++ break;
++
++ case PNG_CMAP_TRANS:
++ for (; outrow < end_row; outrow += stepx)
++ {
++ png_byte gray = *inrow++;
++ png_byte alpha = *inrow++;
++
++ if (alpha == 0)
++ *outrow = PNG_CMAP_TRANS_BACKGROUND;
++
++ else if (gray != PNG_CMAP_TRANS_BACKGROUND)
++ *outrow = gray;
++
++ else
++ *outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1);
++ }
++ break;
++
++ case PNG_CMAP_RGB:
++ for (; outrow < end_row; outrow += stepx)
++ {
++ *outrow = PNG_RGB_INDEX(inrow[0], inrow[1], inrow[2]);
++ inrow += 3;
++ }
++ break;
++
++ case PNG_CMAP_RGB_ALPHA:
++ for (; outrow < end_row; outrow += stepx)
++ {
++ unsigned int alpha = inrow[3];
++
++ /* Because the alpha entries only hold alpha==0.5 values
++ * split the processing at alpha==0.25 (64) and 0.75
++ * (196).
++ */
++
++ if (alpha >= 196)
++ *outrow = PNG_RGB_INDEX(inrow[0], inrow[1],
++ inrow[2]);
++
++ else if (alpha < 64)
++ *outrow = PNG_CMAP_RGB_ALPHA_BACKGROUND;
++
++ else
++ {
++ /* Likewise there are three entries for each of r, g
++ * and b. We could select the entry by popcount on
++ * the top two bits on those architectures that
++ * support it, this is what the code below does,
++ * crudely.
++ */
++ unsigned int back_i = PNG_CMAP_RGB_ALPHA_BACKGROUND+1;
++
++ /* Here are how the values map:
++ *
++ * 0x00 .. 0x3f -> 0
++ * 0x40 .. 0xbf -> 1
++ * 0xc0 .. 0xff -> 2
++ *
++ * So, as above with the explicit alpha checks, the
++ * breakpoints are at 64 and 196.
++ */
++ if (inrow[0] & 0x80) back_i += 9; /* red */
++ if (inrow[0] & 0x40) back_i += 9;
++ if (inrow[0] & 0x80) back_i += 3; /* green */
++ if (inrow[0] & 0x40) back_i += 3;
++ if (inrow[0] & 0x80) back_i += 1; /* blue */
++ if (inrow[0] & 0x40) back_i += 1;
++
++ *outrow = (png_byte)back_i;
++ }
++
++ inrow += 4;
++ }
++ break;
++
++ default:
++ break;
++ }
++ }
++ }
++ }
++
++ return 1;
++}
++
++static int
++png_image_read_colormapped(png_voidp argument)
++{
++ png_image_read_control *display = png_voidcast(png_image_read_control*,
++ argument);
++ png_imagep image = display->image;
++ png_controlp control = image->opaque;
++ png_structrp png_ptr = control->png_ptr;
++ png_inforp info_ptr = control->info_ptr;
++
++ int passes = 0; /* As a flag */
++
++ PNG_SKIP_CHUNKS(png_ptr);
++
++ /* Update the 'info' structure and make sure the result is as required; first
++ * make sure to turn on the interlace handling if it will be required
++ * (because it can't be turned on *after* the call to png_read_update_info!)
++ */
++ if (display->colormap_processing == PNG_CMAP_NONE)
++ passes = png_set_interlace_handling(png_ptr);
++
++ png_read_update_info(png_ptr, info_ptr);
++
++ /* The expected output can be deduced from the colormap_processing option. */
++ switch (display->colormap_processing)
++ {
++ case PNG_CMAP_NONE:
++ /* Output must be one channel and one byte per pixel, the output
++ * encoding can be anything.
++ */
++ if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
++ info_ptr->color_type == PNG_COLOR_TYPE_GRAY) &&
++ info_ptr->bit_depth == 8)
++ break;
++
++ goto bad_output;
++
++ case PNG_CMAP_TRANS:
++ case PNG_CMAP_GA:
++ /* Output must be two channels and the 'G' one must be sRGB, the latter
++ * can be checked with an exact number because it should have been set
++ * to this number above!
++ */
++ if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
++ info_ptr->bit_depth == 8 &&
++ png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
++ image->colormap_entries == 256)
++ break;
++
++ goto bad_output;
++
++ case PNG_CMAP_RGB:
++ /* Output must be 8-bit sRGB encoded RGB */
++ if (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
++ info_ptr->bit_depth == 8 &&
++ png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
++ image->colormap_entries == 216)
++ break;
++
++ goto bad_output;
++
++ case PNG_CMAP_RGB_ALPHA:
++ /* Output must be 8-bit sRGB encoded RGBA */
++ if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
++ info_ptr->bit_depth == 8 &&
++ png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
++ image->colormap_entries == 244 /* 216 + 1 + 27 */)
++ break;
++
++ /* goto bad_output; */
++ /* FALL THROUGH */
++
++ default:
++ bad_output:
++ png_error(png_ptr, "bad color-map processing (internal error)");
++ }
++
++ /* Now read the rows. Do this here if it is possible to read directly into
++ * the output buffer, otherwise allocate a local row buffer of the maximum
++ * size libpng requires and call the relevant processing routine safely.
++ */
++ {
++ png_voidp first_row = display->buffer;
++ ptrdiff_t row_bytes = display->row_stride;
++
++ /* The following expression is designed to work correctly whether it gives
++ * a signed or an unsigned result.
++ */
++ if (row_bytes < 0)
++ {
++ char *ptr = png_voidcast(char*, first_row);
++ ptr += (image->height-1) * (-row_bytes);
++ first_row = png_voidcast(png_voidp, ptr);
++ }
++
++ display->first_row = first_row;
++ display->row_bytes = row_bytes;
++ }
++
++ if (passes == 0)
++ {
++ int result;
++ png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
++
++ display->local_row = row;
++ result = png_safe_execute(image, png_image_read_and_map, display);
++ display->local_row = NULL;
++ png_free(png_ptr, row);
++
++ return result;
++ }
++
++ else
++ {
++ png_alloc_size_t row_bytes = display->row_bytes;
++
++ while (--passes >= 0)
++ {
++ png_uint_32 y = image->height;
++ png_bytep row = png_voidcast(png_bytep, display->first_row);
++
++ while (y-- > 0)
++ {
++ png_read_row(png_ptr, row, NULL);
++ row += row_bytes;
++ }
++ }
++
++ return 1;
++ }
++}
++
++/* Just the row reading part of png_image_read. */
++static int
++png_image_read_composite(png_voidp argument)
++{
++ png_image_read_control *display = png_voidcast(png_image_read_control*,
++ argument);
++ png_imagep image = display->image;
++ png_structrp png_ptr = image->opaque->png_ptr;
++ int passes;
++
++ switch (png_ptr->interlaced)
++ {
++ case PNG_INTERLACE_NONE:
++ passes = 1;
++ break;
++
++ case PNG_INTERLACE_ADAM7:
++ passes = PNG_INTERLACE_ADAM7_PASSES;
++ break;
++
++ default:
++ png_error(png_ptr, "unknown interlace type");
++ }
++
++ {
++ png_uint_32 height = image->height;
++ png_uint_32 width = image->width;
++ ptrdiff_t step_row = display->row_bytes;
++ unsigned int channels =
++ (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
++ int pass;
++
++ for (pass = 0; pass < passes; ++pass)
++ {
++ unsigned int startx, stepx, stepy;
++ png_uint_32 y;
++
++ if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
++ {
++ /* The row may be empty for a short image: */
++ if (PNG_PASS_COLS(width, pass) == 0)
++ continue;
++
++ startx = PNG_PASS_START_COL(pass) * channels;
++ stepx = PNG_PASS_COL_OFFSET(pass) * channels;
++ y = PNG_PASS_START_ROW(pass);
++ stepy = PNG_PASS_ROW_OFFSET(pass);
++ }
++
++ else
++ {
++ y = 0;
++ startx = 0;
++ stepx = channels;
++ stepy = 1;
++ }
++
++ for (; y<height; y += stepy)
++ {
++ png_bytep inrow = png_voidcast(png_bytep, display->local_row);
++ png_bytep outrow;
++ png_const_bytep end_row;
++
++ /* Read the row, which is packed: */
++ png_read_row(png_ptr, inrow, NULL);
++
++ outrow = png_voidcast(png_bytep, display->first_row);
++ outrow += y * step_row;
++ end_row = outrow + width * channels;
++
++ /* Now do the composition on each pixel in this row. */
++ outrow += startx;
++ for (; outrow < end_row; outrow += stepx)
++ {
++ png_byte alpha = inrow[channels];
++
++ if (alpha > 0) /* else no change to the output */
++ {
++ unsigned int c;
++
++ for (c=0; c<channels; ++c)
++ {
++ png_uint_32 component = inrow[c];
++
++ if (alpha < 255) /* else just use component */
++ {
++ /* This is PNG_OPTIMIZED_ALPHA, the component value
++ * is a linear 8-bit value. Combine this with the
++ * current outrow[c] value which is sRGB encoded.
++ * Arithmetic here is 16-bits to preserve the output
++ * values correctly.
++ */
++ component *= 257*255; /* =65535 */
++ component += (255-alpha)*png_sRGB_table[outrow[c]];
++
++ /* So 'component' is scaled by 255*65535 and is
++ * therefore appropriate for the sRGB to linear
++ * conversion table.
++ */
++ component = PNG_sRGB_FROM_LINEAR(component);
++ }
++
++ outrow[c] = (png_byte)component;
++ }
++ }
++
++ inrow += channels+1; /* components and alpha channel */
++ }
++ }
++ }
++ }
++
++ return 1;
++}
++
++/* The do_local_background case; called when all the following transforms are to
++ * be done:
++ *
++ * PNG_RGB_TO_GRAY
++ * PNG_COMPOSITE
++ * PNG_GAMMA
++ *
++ * This is a work-around for the fact that both the PNG_RGB_TO_GRAY and
++ * PNG_COMPOSITE code performs gamma correction, so we get double gamma
++ * correction. The fix-up is to prevent the PNG_COMPOSITE operation from
++ * happening inside libpng, so this routine sees an 8 or 16-bit gray+alpha
++ * row and handles the removal or pre-multiplication of the alpha channel.
++ */
++static int
++png_image_read_background(png_voidp argument)
++{
++ png_image_read_control *display = png_voidcast(png_image_read_control*,
++ argument);
++ png_imagep image = display->image;
++ png_structrp png_ptr = image->opaque->png_ptr;
++ png_inforp info_ptr = image->opaque->info_ptr;
++ png_uint_32 height = image->height;
++ png_uint_32 width = image->width;
++ int pass, passes;
++
++ /* Double check the convoluted logic below. We expect to get here with
++ * libpng doing rgb to gray and gamma correction but background processing
++ * left to the png_image_read_background function. The rows libpng produce
++ * might be 8 or 16-bit but should always have two channels; gray plus alpha.
++ */
++ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
++ png_error(png_ptr, "lost rgb to gray");
++
++ if ((png_ptr->transformations & PNG_COMPOSE) != 0)
++ png_error(png_ptr, "unexpected compose");
++
++ if (png_get_channels(png_ptr, info_ptr) != 2)
++ png_error(png_ptr, "lost/gained channels");
++
++ /* Expect the 8-bit case to always remove the alpha channel */
++ if ((image->format & PNG_FORMAT_FLAG_LINEAR) == 0 &&
++ (image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ png_error(png_ptr, "unexpected 8-bit transformation");
++
++ switch (png_ptr->interlaced)
++ {
++ case PNG_INTERLACE_NONE:
++ passes = 1;
++ break;
++
++ case PNG_INTERLACE_ADAM7:
++ passes = PNG_INTERLACE_ADAM7_PASSES;
++ break;
++
++ default:
++ png_error(png_ptr, "unknown interlace type");
++ }
++
++ /* Use direct access to info_ptr here because otherwise the simplified API
++ * would require PNG_EASY_ACCESS_SUPPORTED (just for this.) Note this is
++ * checking the value after libpng expansions, not the original value in the
++ * PNG.
++ */
++ switch (info_ptr->bit_depth)
++ {
++ default:
++ png_error(png_ptr, "unexpected bit depth");
++ break;
++
++ case 8:
++ /* 8-bit sRGB gray values with an alpha channel; the alpha channel is
++ * to be removed by composing on a background: either the row if
++ * display->background is NULL or display->background->green if not.
++ * Unlike the code above ALPHA_OPTIMIZED has *not* been done.
++ */
++ {
++ png_bytep first_row = png_voidcast(png_bytep, display->first_row);
++ ptrdiff_t step_row = display->row_bytes;
++
++ for (pass = 0; pass < passes; ++pass)
++ {
++ png_bytep row = png_voidcast(png_bytep,
++ display->first_row);
++ unsigned int startx, stepx, stepy;
++ png_uint_32 y;
++
++ if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
++ {
++ /* The row may be empty for a short image: */
++ if (PNG_PASS_COLS(width, pass) == 0)
++ continue;
++
++ startx = PNG_PASS_START_COL(pass);
++ stepx = PNG_PASS_COL_OFFSET(pass);
++ y = PNG_PASS_START_ROW(pass);
++ stepy = PNG_PASS_ROW_OFFSET(pass);
++ }
++
++ else
++ {
++ y = 0;
++ startx = 0;
++ stepx = stepy = 1;
++ }
++
++ if (display->background == NULL)
++ {
++ for (; y<height; y += stepy)
++ {
++ png_bytep inrow = png_voidcast(png_bytep,
++ display->local_row);
++ png_bytep outrow = first_row + y * step_row;
++ png_const_bytep end_row = outrow + width;
++
++ /* Read the row, which is packed: */
++ png_read_row(png_ptr, inrow, NULL);
++
++ /* Now do the composition on each pixel in this row. */
++ outrow += startx;
++ for (; outrow < end_row; outrow += stepx)
++ {
++ png_byte alpha = inrow[1];
++
++ if (alpha > 0) /* else no change to the output */
++ {
++ png_uint_32 component = inrow[0];
++
++ if (alpha < 255) /* else just use component */
++ {
++ /* Since PNG_OPTIMIZED_ALPHA was not set it is
++ * necessary to invert the sRGB transfer
++ * function and multiply the alpha out.
++ */
++ component = png_sRGB_table[component] * alpha;
++ component += png_sRGB_table[outrow[0]] *
++ (255-alpha);
++ component = PNG_sRGB_FROM_LINEAR(component);
++ }
++
++ outrow[0] = (png_byte)component;
++ }
++
++ inrow += 2; /* gray and alpha channel */
++ }
++ }
++ }
++
++ else /* constant background value */
++ {
++ png_byte background8 = display->background->green;
++ png_uint_16 background = png_sRGB_table[background8];
++
++ for (; y<height; y += stepy)
++ {
++ png_bytep inrow = png_voidcast(png_bytep,
++ display->local_row);
++ png_bytep outrow = first_row + y * step_row;
++ png_const_bytep end_row = outrow + width;
++
++ /* Read the row, which is packed: */
++ png_read_row(png_ptr, inrow, NULL);
++
++ /* Now do the composition on each pixel in this row. */
++ outrow += startx;
++ for (; outrow < end_row; outrow += stepx)
++ {
++ png_byte alpha = inrow[1];
++
++ if (alpha > 0) /* else use background */
++ {
++ png_uint_32 component = inrow[0];
++
++ if (alpha < 255) /* else just use component */
++ {
++ component = png_sRGB_table[component] * alpha;
++ component += background * (255-alpha);
++ component = PNG_sRGB_FROM_LINEAR(component);
++ }
++
++ outrow[0] = (png_byte)component;
++ }
++
++ else
++ outrow[0] = background8;
++
++ inrow += 2; /* gray and alpha channel */
++ }
++
++ row += display->row_bytes;
++ }
++ }
++ }
++ }
++ break;
++
++ case 16:
++ /* 16-bit linear with pre-multiplied alpha; the pre-multiplication must
++ * still be done and, maybe, the alpha channel removed. This code also
++ * handles the alpha-first option.
++ */
++ {
++ png_uint_16p first_row = png_voidcast(png_uint_16p,
++ display->first_row);
++ /* The division by two is safe because the caller passed in a
++ * stride which was multiplied by 2 (below) to get row_bytes.
++ */
++ ptrdiff_t step_row = display->row_bytes / 2;
++ int preserve_alpha = (image->format & PNG_FORMAT_FLAG_ALPHA) != 0;
++ unsigned int outchannels = 1+preserve_alpha;
++ int swap_alpha = 0;
++
++# ifdef PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
++ if (preserve_alpha != 0 &&
++ (image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
++ swap_alpha = 1;
++# endif
++
++ for (pass = 0; pass < passes; ++pass)
++ {
++ unsigned int startx, stepx, stepy;
++ png_uint_32 y;
++
++ /* The 'x' start and step are adjusted to output components here.
++ */
++ if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
++ {
++ /* The row may be empty for a short image: */
++ if (PNG_PASS_COLS(width, pass) == 0)
++ continue;
++
++ startx = PNG_PASS_START_COL(pass) * outchannels;
++ stepx = PNG_PASS_COL_OFFSET(pass) * outchannels;
++ y = PNG_PASS_START_ROW(pass);
++ stepy = PNG_PASS_ROW_OFFSET(pass);
++ }
++
++ else
++ {
++ y = 0;
++ startx = 0;
++ stepx = outchannels;
++ stepy = 1;
++ }
++
++ for (; y<height; y += stepy)
++ {
++ png_const_uint_16p inrow;
++ png_uint_16p outrow = first_row + y*step_row;
++ png_uint_16p end_row = outrow + width * outchannels;
++
++ /* Read the row, which is packed: */
++ png_read_row(png_ptr, png_voidcast(png_bytep,
++ display->local_row), NULL);
++ inrow = png_voidcast(png_const_uint_16p, display->local_row);
++
++ /* Now do the pre-multiplication on each pixel in this row.
++ */
++ outrow += startx;
++ for (; outrow < end_row; outrow += stepx)
++ {
++ png_uint_32 component = inrow[0];
++ png_uint_16 alpha = inrow[1];
++
++ if (alpha > 0) /* else 0 */
++ {
++ if (alpha < 65535) /* else just use component */
++ {
++ component *= alpha;
++ component += 32767;
++ component /= 65535;
++ }
++ }
++
++ else
++ component = 0;
++
++ outrow[swap_alpha] = (png_uint_16)component;
++ if (preserve_alpha != 0)
++ outrow[1 ^ swap_alpha] = alpha;
++
++ inrow += 2; /* components and alpha channel */
++ }
++ }
++ }
++ }
++ break;
++ }
++
++ return 1;
++}
++
++/* The guts of png_image_finish_read as a png_safe_execute callback. */
++static int
++png_image_read_direct(png_voidp argument)
++{
++ png_image_read_control *display = png_voidcast(png_image_read_control*,
++ argument);
++ png_imagep image = display->image;
++ png_structrp png_ptr = image->opaque->png_ptr;
++ png_inforp info_ptr = image->opaque->info_ptr;
++
++ png_uint_32 format = image->format;
++ int linear = (format & PNG_FORMAT_FLAG_LINEAR) != 0;
++ int do_local_compose = 0;
++ int do_local_background = 0; /* to avoid double gamma correction bug */
++ int passes = 0;
++
++ /* Add transforms to ensure the correct output format is produced then check
++ * that the required implementation support is there. Always expand; always
++ * need 8 bits minimum, no palette and expanded tRNS.
++ */
++ png_set_expand(png_ptr);
++
++ /* Now check the format to see if it was modified. */
++ {
++ png_uint_32 base_format = png_image_format(png_ptr) &
++ ~PNG_FORMAT_FLAG_COLORMAP /* removed by png_set_expand */;
++ png_uint_32 change = format ^ base_format;
++ png_fixed_point output_gamma;
++ int mode; /* alpha mode */
++
++ /* Do this first so that we have a record if rgb to gray is happening. */
++ if ((change & PNG_FORMAT_FLAG_COLOR) != 0)
++ {
++ /* gray<->color transformation required. */
++ if ((format & PNG_FORMAT_FLAG_COLOR) != 0)
++ png_set_gray_to_rgb(png_ptr);
++
++ else
++ {
++ /* libpng can't do both rgb to gray and
++ * background/pre-multiplication if there is also significant gamma
++ * correction, because both operations require linear colors and
++ * the code only supports one transform doing the gamma correction.
++ * Handle this by doing the pre-multiplication or background
++ * operation in this code, if necessary.
++ *
++ * TODO: fix this by rewriting pngrtran.c (!)
++ *
++ * For the moment (given that fixing this in pngrtran.c is an
++ * enormous change) 'do_local_background' is used to indicate that
++ * the problem exists.
++ */
++ if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ do_local_background = 1/*maybe*/;
++
++ png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
++ PNG_RGB_TO_GRAY_DEFAULT, PNG_RGB_TO_GRAY_DEFAULT);
++ }
++
++ change &= ~PNG_FORMAT_FLAG_COLOR;
++ }
++
++ /* Set the gamma appropriately, linear for 16-bit input, sRGB otherwise.
++ */
++ {
++ png_fixed_point input_gamma_default;
++
++ if ((base_format & PNG_FORMAT_FLAG_LINEAR) != 0 &&
++ (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0)
++ input_gamma_default = PNG_GAMMA_LINEAR;
++ else
++ input_gamma_default = PNG_DEFAULT_sRGB;
++
++ /* Call png_set_alpha_mode to set the default for the input gamma; the
++ * output gamma is set by a second call below.
++ */
++ png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default);
++ }
++
++ if (linear != 0)
++ {
++ /* If there *is* an alpha channel in the input it must be multiplied
++ * out; use PNG_ALPHA_STANDARD, otherwise just use PNG_ALPHA_PNG.
++ */
++ if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ mode = PNG_ALPHA_STANDARD; /* associated alpha */
++
++ else
++ mode = PNG_ALPHA_PNG;
++
++ output_gamma = PNG_GAMMA_LINEAR;
++ }
++
++ else
++ {
++ mode = PNG_ALPHA_PNG;
++ output_gamma = PNG_DEFAULT_sRGB;
++ }
++
++ /* If 'do_local_background' is set check for the presence of gamma
++ * correction; this is part of the work-round for the libpng bug
++ * described above.
++ *
++ * TODO: fix libpng and remove this.
++ */
++ if (do_local_background != 0)
++ {
++ png_fixed_point gtest;
++
++ /* This is 'png_gamma_threshold' from pngrtran.c; the test used for
++ * gamma correction, the screen gamma hasn't been set on png_struct
++ * yet; it's set below. png_struct::gamma, however, is set to the
++ * final value.
++ */
++ if (png_muldiv(&gtest, output_gamma, png_ptr->colorspace.gamma,
++ PNG_FP_1) != 0 && png_gamma_significant(gtest) == 0)
++ do_local_background = 0;
++
++ else if (mode == PNG_ALPHA_STANDARD)
++ {
++ do_local_background = 2/*required*/;
++ mode = PNG_ALPHA_PNG; /* prevent libpng doing it */
++ }
++
++ /* else leave as 1 for the checks below */
++ }
++
++ /* If the bit-depth changes then handle that here. */
++ if ((change & PNG_FORMAT_FLAG_LINEAR) != 0)
++ {
++ if (linear != 0 /*16-bit output*/)
++ png_set_expand_16(png_ptr);
++
++ else /* 8-bit output */
++ png_set_scale_16(png_ptr);
++
++ change &= ~PNG_FORMAT_FLAG_LINEAR;
++ }
++
++ /* Now the background/alpha channel changes. */
++ if ((change & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++ /* Removing an alpha channel requires composition for the 8-bit
++ * formats; for the 16-bit it is already done, above, by the
++ * pre-multiplication and the channel just needs to be stripped.
++ */
++ if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++ /* If RGB->gray is happening the alpha channel must be left and the
++ * operation completed locally.
++ *
++ * TODO: fix libpng and remove this.
++ */
++ if (do_local_background != 0)
++ do_local_background = 2/*required*/;
++
++ /* 16-bit output: just remove the channel */
++ else if (linear != 0) /* compose on black (well, pre-multiply) */
++ png_set_strip_alpha(png_ptr);
++
++ /* 8-bit output: do an appropriate compose */
++ else if (display->background != NULL)
++ {
++ png_color_16 c;
++
++ c.index = 0; /*unused*/
++ c.red = display->background->red;
++ c.green = display->background->green;
++ c.blue = display->background->blue;
++ c.gray = display->background->green;
++
++ /* This is always an 8-bit sRGB value, using the 'green' channel
++ * for gray is much better than calculating the luminance here;
++ * we can get off-by-one errors in that calculation relative to
++ * the app expectations and that will show up in transparent
++ * pixels.
++ */
++ png_set_background_fixed(png_ptr, &c,
++ PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
++ 0/*gamma: not used*/);
++ }
++
++ else /* compose on row: implemented below. */
++ {
++ do_local_compose = 1;
++ /* This leaves the alpha channel in the output, so it has to be
++ * removed by the code below. Set the encoding to the 'OPTIMIZE'
++ * one so the code only has to hack on the pixels that require
++ * composition.
++ */
++ mode = PNG_ALPHA_OPTIMIZED;
++ }
++ }
++
++ else /* output needs an alpha channel */
++ {
++ /* This is tricky because it happens before the swap operation has
++ * been accomplished; however, the swap does *not* swap the added
++ * alpha channel (weird API), so it must be added in the correct
++ * place.
++ */
++ png_uint_32 filler; /* opaque filler */
++ int where;
++
++ if (linear != 0)
++ filler = 65535;
++
++ else
++ filler = 255;
++
++# ifdef PNG_FORMAT_AFIRST_SUPPORTED
++ if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
++ {
++ where = PNG_FILLER_BEFORE;
++ change &= ~PNG_FORMAT_FLAG_AFIRST;
++ }
++
++ else
++# endif
++ where = PNG_FILLER_AFTER;
++
++ png_set_add_alpha(png_ptr, filler, where);
++ }
++
++ /* This stops the (irrelevant) call to swap_alpha below. */
++ change &= ~PNG_FORMAT_FLAG_ALPHA;
++ }
++
++ /* Now set the alpha mode correctly; this is always done, even if there is
++ * no alpha channel in either the input or the output because it correctly
++ * sets the output gamma.
++ */
++ png_set_alpha_mode_fixed(png_ptr, mode, output_gamma);
++
++# ifdef PNG_FORMAT_BGR_SUPPORTED
++ if ((change & PNG_FORMAT_FLAG_BGR) != 0)
++ {
++ /* Check only the output format; PNG is never BGR; don't do this if
++ * the output is gray, but fix up the 'format' value in that case.
++ */
++ if ((format & PNG_FORMAT_FLAG_COLOR) != 0)
++ png_set_bgr(png_ptr);
++
++ else
++ format &= ~PNG_FORMAT_FLAG_BGR;
++
++ change &= ~PNG_FORMAT_FLAG_BGR;
++ }
++# endif
++
++# ifdef PNG_FORMAT_AFIRST_SUPPORTED
++ if ((change & PNG_FORMAT_FLAG_AFIRST) != 0)
++ {
++ /* Only relevant if there is an alpha channel - it's particularly
++ * important to handle this correctly because do_local_compose may
++ * be set above and then libpng will keep the alpha channel for this
++ * code to remove.
++ */
++ if ((format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++ /* Disable this if doing a local background,
++ * TODO: remove this when local background is no longer required.
++ */
++ if (do_local_background != 2)
++ png_set_swap_alpha(png_ptr);
++ }
++
++ else
++ format &= ~PNG_FORMAT_FLAG_AFIRST;
++
++ change &= ~PNG_FORMAT_FLAG_AFIRST;
++ }
++# endif
++
++ /* If the *output* is 16-bit then we need to check for a byte-swap on this
++ * architecture.
++ */
++ if (linear != 0)
++ {
++ PNG_CONST png_uint_16 le = 0x0001;
++
++ if ((*(png_const_bytep) & le) != 0)
++ png_set_swap(png_ptr);
++ }
++
++ /* If change is not now 0 some transformation is missing - error out. */
++ if (change != 0)
++ png_error(png_ptr, "png_read_image: unsupported transformation");
++ }
++
++ PNG_SKIP_CHUNKS(png_ptr);
++
++ /* Update the 'info' structure and make sure the result is as required; first
++ * make sure to turn on the interlace handling if it will be required
++ * (because it can't be turned on *after* the call to png_read_update_info!)
++ *
++ * TODO: remove the do_local_background fixup below.
++ */
++ if (do_local_compose == 0 && do_local_background != 2)
++ passes = png_set_interlace_handling(png_ptr);
++
++ png_read_update_info(png_ptr, info_ptr);
++
++ {
++ png_uint_32 info_format = 0;
++
++ if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
++ info_format |= PNG_FORMAT_FLAG_COLOR;
++
++ if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
++ {
++ /* do_local_compose removes this channel below. */
++ if (do_local_compose == 0)
++ {
++ /* do_local_background does the same if required. */
++ if (do_local_background != 2 ||
++ (format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ info_format |= PNG_FORMAT_FLAG_ALPHA;
++ }
++ }
++
++ else if (do_local_compose != 0) /* internal error */
++ png_error(png_ptr, "png_image_read: alpha channel lost");
++
++ if (info_ptr->bit_depth == 16)
++ info_format |= PNG_FORMAT_FLAG_LINEAR;
++
++# ifdef PNG_FORMAT_BGR_SUPPORTED
++ if ((png_ptr->transformations & PNG_BGR) != 0)
++ info_format |= PNG_FORMAT_FLAG_BGR;
++# endif
++
++# ifdef PNG_FORMAT_AFIRST_SUPPORTED
++ if (do_local_background == 2)
++ {
++ if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
++ info_format |= PNG_FORMAT_FLAG_AFIRST;
++ }
++
++ if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 ||
++ ((png_ptr->transformations & PNG_ADD_ALPHA) != 0 &&
++ (png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0))
++ {
++ if (do_local_background == 2)
++ png_error(png_ptr, "unexpected alpha swap transformation");
++
++ info_format |= PNG_FORMAT_FLAG_AFIRST;
++ }
++# endif
++
++ /* This is actually an internal error. */
++ if (info_format != format)
++ png_error(png_ptr, "png_read_image: invalid transformations");
++ }
++
++ /* Now read the rows. If do_local_compose is set then it is necessary to use
++ * a local row buffer. The output will be GA, RGBA or BGRA and must be
++ * converted to G, RGB or BGR as appropriate. The 'local_row' member of the
++ * display acts as a flag.
++ */
++ {
++ png_voidp first_row = display->buffer;
++ ptrdiff_t row_bytes = display->row_stride;
++
++ if (linear != 0)
++ row_bytes *= 2;
++
++ /* The following expression is designed to work correctly whether it gives
++ * a signed or an unsigned result.
++ */
++ if (row_bytes < 0)
++ {
++ char *ptr = png_voidcast(char*, first_row);
++ ptr += (image->height-1) * (-row_bytes);
++ first_row = png_voidcast(png_voidp, ptr);
++ }
++
++ display->first_row = first_row;
++ display->row_bytes = row_bytes;
++ }
++
++ if (do_local_compose != 0)
++ {
++ int result;
++ png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
++
++ display->local_row = row;
++ result = png_safe_execute(image, png_image_read_composite, display);
++ display->local_row = NULL;
++ png_free(png_ptr, row);
++
++ return result;
++ }
++
++ else if (do_local_background == 2)
++ {
++ int result;
++ png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
++
++ display->local_row = row;
++ result = png_safe_execute(image, png_image_read_background, display);
++ display->local_row = NULL;
++ png_free(png_ptr, row);
++
++ return result;
++ }
++
++ else
++ {
++ png_alloc_size_t row_bytes = display->row_bytes;
++
++ while (--passes >= 0)
++ {
++ png_uint_32 y = image->height;
++ png_bytep row = png_voidcast(png_bytep, display->first_row);
++
++ while (y-- > 0)
++ {
++ png_read_row(png_ptr, row, NULL);
++ row += row_bytes;
++ }
++ }
++
++ return 1;
++ }
++}
++
++int PNGAPI
++png_image_finish_read(png_imagep image, png_const_colorp background,
++ void *buffer, png_int_32 row_stride, void *colormap)
++{
++ if (image != NULL && image->version == PNG_IMAGE_VERSION)
++ {
++ png_uint_32 check;
++
++ if (row_stride == 0)
++ row_stride = PNG_IMAGE_ROW_STRIDE(*image);
++
++ if (row_stride < 0)
++ check = -row_stride;
++
++ else
++ check = row_stride;
++
++ if (image->opaque != NULL && buffer != NULL &&
++ check >= PNG_IMAGE_ROW_STRIDE(*image))
++ {
++ if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 ||
++ (image->colormap_entries > 0 && colormap != NULL))
++ {
++ int result;
++ png_image_read_control display;
++
++ memset(&display, 0, (sizeof display));
++ display.image = image;
++ display.buffer = buffer;
++ display.row_stride = row_stride;
++ display.colormap = colormap;
++ display.background = background;
++ display.local_row = NULL;
++
++ /* Choose the correct 'end' routine; for the color-map case all the
++ * setup has already been done.
++ */
++ if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0)
++ result =
++ png_safe_execute(image, png_image_read_colormap, &display) &&
++ png_safe_execute(image, png_image_read_colormapped, &display);
++
++ else
++ result =
++ png_safe_execute(image, png_image_read_direct, &display);
++
++ png_image_free(image);
++ return result;
++ }
++
++ else
++ return png_image_error(image,
++ "png_image_finish_read[color-map]: no color-map");
++ }
++
++ else
++ return png_image_error(image,
++ "png_image_finish_read: invalid argument");
++ }
++
++ else if (image != NULL)
++ return png_image_error(image,
++ "png_image_finish_read: damaged PNG_IMAGE_VERSION");
++
++ return 0;
++}
++
++#endif /* SIMPLIFIED_READ */
++#endif /* READ */
+--- ./jdk/src/share/native/sun/awt/libpng/pngrio.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngrio.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.0 [January 6, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -57,7 +57,7 @@
+ * to read more then 64K on a 16 bit machine.
+ */
+ void /* PRIVATE */
+-png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
++png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length)
+ {
+ png_debug1(4, "reading %d bytes", (int)length);
+
+@@ -74,7 +74,6 @@
+ * read_data function and use it at run time with png_set_read_fn(), rather
+ * than changing the library.
+ */
+-# ifndef USE_FAR_KEYWORD
+ void PNGCBAPI
+ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+ {
+@@ -86,68 +85,11 @@
+ /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+ * instead of an int, which is what fread() actually returns.
+ */
+- check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr);
++ check = fread(data, 1, length, png_voidcast(png_FILE_p, png_ptr->io_ptr));
+
+ if (check != length)
+ png_error(png_ptr, "Read Error");
+ }
+-# else
+-/* This is the model-independent version. Since the standard I/O library
+- can't handle far buffers in the medium and small models, we have to copy
+- the data.
+-*/
+-
+-#define NEAR_BUF_SIZE 1024
+-#define MIN(a,b) (a <= b ? a : b)
+-
+-static void PNGCBAPI
+-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+-{
+- png_size_t check;
+- png_byte *n_data;
+- png_FILE_p io_ptr;
+-
+- if (png_ptr == NULL)
+- return;
+-
+- /* Check if data really is near. If so, use usual code. */
+- n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+-
+- if ((png_bytep)n_data == data)
+- {
+- check = fread(n_data, 1, length, io_ptr);
+- }
+-
+- else
+- {
+- png_byte buf[NEAR_BUF_SIZE];
+- png_size_t read, remaining, err;
+- check = 0;
+- remaining = length;
+-
+- do
+- {
+- read = MIN(NEAR_BUF_SIZE, remaining);
+- err = fread(buf, 1, read, io_ptr);
+- png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+-
+- if (err != read)
+- break;
+-
+- else
+- check += err;
+-
+- data += read;
+- remaining -= read;
+- }
+- while (remaining != 0);
+- }
+-
+- if ((png_uint_32)check != (png_uint_32)length)
+- png_error(png_ptr, "read Error");
+-}
+-# endif
+ #endif
+
+ /* This function allows the application to supply a new input function
+@@ -170,7 +112,7 @@
+ * be used.
+ */
+ void PNGAPI
+-png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
++png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
+ png_rw_ptr read_data_fn)
+ {
+ if (png_ptr == NULL)
+@@ -188,6 +130,7 @@
+ png_ptr->read_data_fn = read_data_fn;
+ #endif
+
++#ifdef PNG_WRITE_SUPPORTED
+ /* It is an error to write to a read device */
+ if (png_ptr->write_data_fn != NULL)
+ {
+@@ -196,9 +139,10 @@
+ "Can't set both read_data_fn and write_data_fn in the"
+ " same structure");
+ }
++#endif
+
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+ png_ptr->output_flush_fn = NULL;
+ #endif
+ }
+-#endif /* PNG_READ_SUPPORTED */
++#endif /* READ */
+--- ./jdk/src/share/native/sun/awt/libpng/pngrtran.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngrtran.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -50,7 +50,7 @@
+
+ /* Set the action on getting a CRC error for an ancillary or critical chunk. */
+ void PNGAPI
+-png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
++png_set_crc_action(png_structrp png_ptr, int crit_action, int ancil_action)
+ {
+ png_debug(1, "in png_set_crc_action");
+
+@@ -116,16 +116,47 @@
+ }
+ }
+
++#ifdef PNG_READ_TRANSFORMS_SUPPORTED
++/* Is it OK to set a transformation now? Only if png_start_read_image or
++ * png_read_update_info have not been called. It is not necessary for the IHDR
++ * to have been read in all cases; the need_IHDR parameter allows for this
++ * check too.
++ */
++static int
++png_rtran_ok(png_structrp png_ptr, int need_IHDR)
++{
++ if (png_ptr != NULL)
++ {
++ if ((png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
++ png_app_error(png_ptr,
++ "invalid after png_start_read_image or png_read_update_info");
++
++ else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_app_error(png_ptr, "invalid before the PNG header has been read");
++
++ else
++ {
++ /* Turn on failure to initialize correctly for all transforms. */
++ png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED;
++
++ return 1; /* Ok */
++ }
++ }
++
++ return 0; /* no png_error possible! */
++}
++#endif
++
+ #ifdef PNG_READ_BACKGROUND_SUPPORTED
+ /* Handle alpha and tRNS via a background color */
+ void PNGFAPI
+-png_set_background_fixed(png_structp png_ptr,
++png_set_background_fixed(png_structrp png_ptr,
+ png_const_color_16p background_color, int background_gamma_code,
+ int need_expand, png_fixed_point background_gamma)
+ {
+ png_debug(1, "in png_set_background_fixed");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0 || background_color == NULL)
+ return;
+
+ if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
+@@ -138,11 +169,10 @@
+ png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
+ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
+
+- png_memcpy(&(png_ptr->background), background_color,
+- png_sizeof(png_color_16));
++ png_ptr->background = *background_color;
+ png_ptr->background_gamma = background_gamma;
+ png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
+- if (need_expand)
++ if (need_expand != 0)
+ png_ptr->transformations |= PNG_BACKGROUND_EXPAND;
+ else
+ png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
+@@ -150,7 +180,7 @@
+
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ void PNGAPI
+-png_set_background(png_structp png_ptr,
++png_set_background(png_structrp png_ptr,
+ png_const_color_16p background_color, int background_gamma_code,
+ int need_expand, double background_gamma)
+ {
+@@ -166,11 +196,11 @@
+ */
+ #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+ void PNGAPI
+-png_set_scale_16(png_structp png_ptr)
++png_set_scale_16(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_scale_16");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= PNG_SCALE_16_TO_8;
+@@ -180,11 +210,11 @@
+ #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+ /* Chop 16-bit depth files to 8-bit depth */
+ void PNGAPI
+-png_set_strip_16(png_structp png_ptr)
++png_set_strip_16(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_strip_16");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= PNG_16_TO_8;
+@@ -193,11 +223,11 @@
+
+ #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+ void PNGAPI
+-png_set_strip_alpha(png_structp png_ptr)
++png_set_strip_alpha(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_strip_alpha");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= PNG_STRIP_ALPHA;
+@@ -206,7 +236,7 @@
+
+ #if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED)
+ static png_fixed_point
+-translate_gamma_flags(png_structp png_ptr, png_fixed_point output_gamma,
++translate_gamma_flags(png_structrp png_ptr, png_fixed_point output_gamma,
+ int is_screen)
+ {
+ /* Check for flag values. The main reason for having the old Mac value as a
+@@ -222,8 +252,10 @@
+ */
+ # ifdef PNG_READ_sRGB_SUPPORTED
+ png_ptr->flags |= PNG_FLAG_ASSUME_sRGB;
++# else
++ PNG_UNUSED(png_ptr)
+ # endif
+- if (is_screen)
++ if (is_screen != 0)
+ output_gamma = PNG_GAMMA_sRGB;
+ else
+ output_gamma = PNG_GAMMA_sRGB_INVERSE;
+@@ -232,7 +264,7 @@
+ else if (output_gamma == PNG_GAMMA_MAC_18 ||
+ output_gamma == PNG_FP_1 / PNG_GAMMA_MAC_18)
+ {
+- if (is_screen)
++ if (is_screen != 0)
+ output_gamma = PNG_GAMMA_MAC_OLD;
+ else
+ output_gamma = PNG_GAMMA_MAC_INVERSE;
+@@ -243,7 +275,7 @@
+
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ static png_fixed_point
+-convert_gamma_value(png_structp png_ptr, double output_gamma)
++convert_gamma_value(png_structrp png_ptr, double output_gamma)
+ {
+ /* The following silently ignores cases where fixed point (times 100,000)
+ * gamma values are passed to the floating point API. This is safe and it
+@@ -268,7 +300,7 @@
+
+ #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+ void PNGFAPI
+-png_set_alpha_mode_fixed(png_structp png_ptr, int mode,
++png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
+ png_fixed_point output_gamma)
+ {
+ int compose = 0;
+@@ -276,7 +308,7 @@
+
+ png_debug(1, "in png_set_alpha_mode");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/);
+@@ -348,8 +380,11 @@
+ * the side effect that the gamma in a second call to png_set_alpha_mode will
+ * be ignored.)
+ */
+- if (png_ptr->gamma == 0)
+- png_ptr->gamma = file_gamma;
++ if (png_ptr->colorspace.gamma == 0)
++ {
++ png_ptr->colorspace.gamma = file_gamma;
++ png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
++ }
+
+ /* But always set the output gamma: */
+ png_ptr->screen_gamma = output_gamma;
+@@ -357,28 +392,25 @@
+ /* Finally, if pre-multiplying, set the background fields to achieve the
+ * desired result.
+ */
+- if (compose)
++ if (compose != 0)
+ {
+ /* And obtain alpha pre-multiplication by composing on black: */
+- png_memset(&png_ptr->background, 0, sizeof png_ptr->background);
+- png_ptr->background_gamma = png_ptr->gamma; /* just in case */
++ memset(&png_ptr->background, 0, (sizeof png_ptr->background));
++ png_ptr->background_gamma = png_ptr->colorspace.gamma; /* just in case */
+ png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE;
+ png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
+
+- if (png_ptr->transformations & PNG_COMPOSE)
++ if ((png_ptr->transformations & PNG_COMPOSE) != 0)
+ png_error(png_ptr,
+ "conflicting calls to set alpha mode and background");
+
+ png_ptr->transformations |= PNG_COMPOSE;
+ }
+-
+- /* New API, make sure apps call the correct initializers: */
+- png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED;
+ }
+
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ void PNGAPI
+-png_set_alpha_mode(png_structp png_ptr, int mode, double output_gamma)
++png_set_alpha_mode(png_structrp png_ptr, int mode, double output_gamma)
+ {
+ png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr,
+ output_gamma));
+@@ -398,31 +430,31 @@
+
+ typedef struct png_dsort_struct
+ {
+- struct png_dsort_struct FAR * next;
++ struct png_dsort_struct * next;
+ png_byte left;
+ png_byte right;
+ } png_dsort;
+-typedef png_dsort FAR * png_dsortp;
+-typedef png_dsort FAR * FAR * png_dsortpp;
++typedef png_dsort * png_dsortp;
++typedef png_dsort * * png_dsortpp;
+
+ void PNGAPI
+-png_set_quantize(png_structp png_ptr, png_colorp palette,
++png_set_quantize(png_structrp png_ptr, png_colorp palette,
+ int num_palette, int maximum_colors, png_const_uint_16p histogram,
+ int full_quantize)
+ {
+ png_debug(1, "in png_set_quantize");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= PNG_QUANTIZE;
+
+- if (!full_quantize)
++ if (full_quantize == 0)
+ {
+ int i;
+
+ png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr,
+- (png_uint_32)(num_palette * png_sizeof(png_byte)));
++ (png_uint_32)(num_palette * (sizeof (png_byte))));
+ for (i = 0; i < num_palette; i++)
+ png_ptr->quantize_index[i] = (png_byte)i;
+ }
+@@ -439,7 +471,7 @@
+
+ /* Initialize an array to sort colors */
+ png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr,
+- (png_uint_32)(num_palette * png_sizeof(png_byte)));
++ (png_uint_32)(num_palette * (sizeof (png_byte))));
+
+ /* Initialize the quantize_sort array */
+ for (i = 0; i < num_palette; i++)
+@@ -472,12 +504,12 @@
+ }
+ }
+
+- if (done)
++ if (done != 0)
+ break;
+ }
+
+ /* Swap the palette around, and set up a table, if necessary */
+- if (full_quantize)
++ if (full_quantize != 0)
+ {
+ int j = num_palette;
+
+@@ -573,9 +605,9 @@
+
+ /* Initialize palette index arrays */
+ png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
+- (png_uint_32)(num_palette * png_sizeof(png_byte)));
++ (png_uint_32)(num_palette * (sizeof (png_byte))));
+ png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
+- (png_uint_32)(num_palette * png_sizeof(png_byte)));
++ (png_uint_32)(num_palette * (sizeof (png_byte))));
+
+ /* Initialize the sort array */
+ for (i = 0; i < num_palette; i++)
+@@ -585,7 +617,7 @@
+ }
+
+ hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *
+- png_sizeof(png_dsortp)));
++ (sizeof (png_dsortp))));
+
+ num_new_palette = num_palette;
+
+@@ -615,7 +647,7 @@
+ {
+
+ t = (png_dsortp)png_malloc_warn(png_ptr,
+- (png_uint_32)(png_sizeof(png_dsort)));
++ (png_uint_32)(sizeof (png_dsort)));
+
+ if (t == NULL)
+ break;
+@@ -660,7 +692,7 @@
+ num_new_palette--;
+ palette[png_ptr->index_to_palette[j]]
+ = palette[num_new_palette];
+- if (!full_quantize)
++ if (full_quantize == 0)
+ {
+ int k;
+
+@@ -728,7 +760,7 @@
+ }
+ png_ptr->num_palette = (png_uint_16)num_palette;
+
+- if (full_quantize)
++ if (full_quantize != 0)
+ {
+ int i;
+ png_bytep distance;
+@@ -740,12 +772,12 @@
+ png_size_t num_entries = ((png_size_t)1 << total_bits);
+
+ png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,
+- (png_uint_32)(num_entries * png_sizeof(png_byte)));
++ (png_uint_32)(num_entries * (sizeof (png_byte))));
+
+ distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
+- png_sizeof(png_byte)));
+-
+- png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
++ (sizeof (png_byte))));
++
++ memset(distance, 0xff, num_entries * (sizeof (png_byte)));
+
+ for (i = 0; i < num_palette; i++)
+ {
+@@ -790,23 +822,22 @@
+ png_free(png_ptr, distance);
+ }
+ }
+-#endif /* PNG_READ_QUANTIZE_SUPPORTED */
++#endif /* READ_QUANTIZE */
+
+ #ifdef PNG_READ_GAMMA_SUPPORTED
+ void PNGFAPI
+-png_set_gamma_fixed(png_structp png_ptr, png_fixed_point scrn_gamma,
++png_set_gamma_fixed(png_structrp png_ptr, png_fixed_point scrn_gamma,
+ png_fixed_point file_gamma)
+ {
+ png_debug(1, "in png_set_gamma_fixed");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ /* New in libpng-1.5.4 - reserve particular negative values as flags. */
+ scrn_gamma = translate_gamma_flags(png_ptr, scrn_gamma, 1/*screen*/);
+ file_gamma = translate_gamma_flags(png_ptr, file_gamma, 0/*file*/);
+
+-#if PNG_LIBPNG_VER >= 10600
+ /* Checking the gamma values for being >0 was added in 1.5.4 along with the
+ * premultiplied alpha support; this actually hides an undocumented feature
+ * of the previous implementation which allowed gamma processing to be
+@@ -815,31 +846,32 @@
+ * accept '0' for the gamma value it takes, because it isn't always used.
+ *
+ * Since this is an API change (albeit a very minor one that removes an
+- * undocumented API feature) it will not be made until libpng-1.6.0.
++ * undocumented API feature) the following checks were only enabled in
++ * libpng-1.6.0.
+ */
+ if (file_gamma <= 0)
+ png_error(png_ptr, "invalid file gamma in png_set_gamma");
+
+ if (scrn_gamma <= 0)
+ png_error(png_ptr, "invalid screen gamma in png_set_gamma");
+-#endif
+
+ /* Set the gamma values unconditionally - this overrides the value in the PNG
+ * file if a gAMA chunk was present. png_set_alpha_mode provides a
+ * different, easier, way to default the file gamma.
+ */
+- png_ptr->gamma = file_gamma;
++ png_ptr->colorspace.gamma = file_gamma;
++ png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
+ png_ptr->screen_gamma = scrn_gamma;
+ }
+
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ void PNGAPI
+-png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
++png_set_gamma(png_structrp png_ptr, double scrn_gamma, double file_gamma)
+ {
+ png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma),
+ convert_gamma_value(png_ptr, file_gamma));
+ }
+-# endif /* FLOATING_POINT_SUPPORTED */
++# endif /* FLOATING_POINT */
+ #endif /* READ_GAMMA */
+
+ #ifdef PNG_READ_EXPAND_SUPPORTED
+@@ -848,15 +880,14 @@
+ * to alpha channels.
+ */
+ void PNGAPI
+-png_set_expand(png_structp png_ptr)
++png_set_expand(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_expand");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+- png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+ }
+
+ /* GRR 19990627: the following three functions currently are identical
+@@ -879,100 +910,95 @@
+
+ /* Expand paletted images to RGB. */
+ void PNGAPI
+-png_set_palette_to_rgb(png_structp png_ptr)
++png_set_palette_to_rgb(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_palette_to_rgb");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+- png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+ }
+
+ /* Expand grayscale images of less than 8-bit depth to 8 bits. */
+ void PNGAPI
+-png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
++png_set_expand_gray_1_2_4_to_8(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= PNG_EXPAND;
+- png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+ }
+
+-
+-
+ /* Expand tRNS chunks to alpha channels. */
+ void PNGAPI
+-png_set_tRNS_to_alpha(png_structp png_ptr)
++png_set_tRNS_to_alpha(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_tRNS_to_alpha");
+
++ if (png_rtran_ok(png_ptr, 0) == 0)
++ return;
++
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
+- png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+ }
+-#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
++#endif /* READ_EXPAND */
+
+ #ifdef PNG_READ_EXPAND_16_SUPPORTED
+ /* Expand to 16-bit channels, expand the tRNS chunk too (because otherwise
+ * it may not work correctly.)
+ */
+ void PNGAPI
+-png_set_expand_16(png_structp png_ptr)
++png_set_expand_16(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_expand_16");
+
+- if (png_ptr == NULL)
++ if (png_rtran_ok(png_ptr, 0) == 0)
+ return;
+
+ png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS);
+- png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+-
+- /* New API, make sure apps call the correct initializers: */
+- png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED;
+ }
+ #endif
+
+ #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+ void PNGAPI
+-png_set_gray_to_rgb(png_structp png_ptr)
++png_set_gray_to_rgb(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_gray_to_rgb");
+
+- if (png_ptr != NULL)
+- {
+- /* Because rgb must be 8 bits or more: */
+- png_set_expand_gray_1_2_4_to_8(png_ptr);
+- png_ptr->transformations |= PNG_GRAY_TO_RGB;
+- png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
+- }
++ if (png_rtran_ok(png_ptr, 0) == 0)
++ return;
++
++ /* Because rgb must be 8 bits or more: */
++ png_set_expand_gray_1_2_4_to_8(png_ptr);
++ png_ptr->transformations |= PNG_GRAY_TO_RGB;
+ }
+ #endif
+
+ #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+ void PNGFAPI
+-png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
++png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
+ png_fixed_point red, png_fixed_point green)
+ {
+ png_debug(1, "in png_set_rgb_to_gray");
+
+- if (png_ptr == NULL)
++ /* Need the IHDR here because of the check on color_type below. */
++ /* TODO: fix this */
++ if (png_rtran_ok(png_ptr, 1) == 0)
+ return;
+
+- switch(error_action)
++ switch (error_action)
+ {
+- case 1:
++ case PNG_ERROR_ACTION_NONE:
+ png_ptr->transformations |= PNG_RGB_TO_GRAY;
+ break;
+
+- case 2:
++ case PNG_ERROR_ACTION_WARN:
+ png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
+ break;
+
+- case 3:
++ case PNG_ERROR_ACTION_ERROR:
+ png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
+ break;
+
+@@ -980,15 +1006,19 @@
+ png_error(png_ptr, "invalid error action to rgb_to_gray");
+ break;
+ }
++
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ #ifdef PNG_READ_EXPAND_SUPPORTED
+ png_ptr->transformations |= PNG_EXPAND;
+ #else
+ {
+- png_warning(png_ptr,
++ /* Make this an error in 1.6 because otherwise the application may assume
++ * that it just worked and get a memory overwrite.
++ */
++ png_error(png_ptr,
+ "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");
+
+- png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
++ /* png_ptr->transformations &= ~PNG_RGB_TO_GRAY; */
+ }
+ #endif
+ {
+@@ -996,32 +1026,37 @@
+ {
+ png_uint_16 red_int, green_int;
+
+- red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
+- green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
++ /* NOTE: this calculation does not round, but this behavior is retained
++ * for consistency; the inaccuracy is very small. The code here always
++ * overwrites the coefficients, regardless of whether they have been
++ * defaulted or set already.
++ */
++ red_int = (png_uint_16)(((png_uint_32)red*32768)/100000);
++ green_int = (png_uint_16)(((png_uint_32)green*32768)/100000);
+
+ png_ptr->rgb_to_gray_red_coeff = red_int;
+ png_ptr->rgb_to_gray_green_coeff = green_int;
+- png_ptr->rgb_to_gray_blue_coeff =
+- (png_uint_16)(32768 - red_int - green_int);
++ png_ptr->rgb_to_gray_coefficients_set = 1;
+ }
+
+ else
+ {
+ if (red >= 0 && green >= 0)
+- png_warning(png_ptr,
++ png_app_warning(png_ptr,
+ "ignoring out of range rgb_to_gray coefficients");
+
+- /* Use the defaults, from the cHRM chunk if set, else the built in Rec
+- * 709 values (which correspond to sRGB, so we don't have to worry
+- * about the sRGB chunk!)
++ /* Use the defaults, from the cHRM chunk if set, else the historical
++ * values which are close to the sRGB/HDTV/ITU-Rec 709 values. See
++ * png_do_rgb_to_gray for more discussion of the values. In this case
++ * the coefficients are not marked as 'set' and are not overwritten if
++ * something has already provided a default.
+ */
+ if (png_ptr->rgb_to_gray_red_coeff == 0 &&
+- png_ptr->rgb_to_gray_green_coeff == 0 &&
+- png_ptr->rgb_to_gray_blue_coeff == 0)
++ png_ptr->rgb_to_gray_green_coeff == 0)
+ {
+- png_ptr->rgb_to_gray_red_coeff = 6968; /* .212671 * 32768 + .5 */
+- png_ptr->rgb_to_gray_green_coeff = 23434; /* .715160 * 32768 + .5 */
+- png_ptr->rgb_to_gray_blue_coeff = 2366;
++ png_ptr->rgb_to_gray_red_coeff = 6968;
++ png_ptr->rgb_to_gray_green_coeff = 23434;
++ /* png_ptr->rgb_to_gray_blue_coeff = 2366; */
+ }
+ }
+ }
+@@ -1033,31 +1068,25 @@
+ */
+
+ void PNGAPI
+-png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
++png_set_rgb_to_gray(png_structrp png_ptr, int error_action, double red,
+ double green)
+ {
+- if (png_ptr == NULL)
+- return;
+-
+ png_set_rgb_to_gray_fixed(png_ptr, error_action,
+ png_fixed(png_ptr, red, "rgb to gray red coefficient"),
+ png_fixed(png_ptr, green, "rgb to gray green coefficient"));
+ }
+ #endif /* FLOATING POINT */
+
+-#endif
++#endif /* RGB_TO_GRAY */
+
+ #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+ void PNGAPI
+-png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
++png_set_read_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr
+ read_user_transform_fn)
+ {
+ png_debug(1, "in png_set_read_user_transform_fn");
+
+- if (png_ptr == NULL)
+- return;
+-
+ #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+ png_ptr->transformations |= PNG_USER_TRANSFORM;
+ png_ptr->read_user_transform_fn = read_user_transform_fn;
+@@ -1091,13 +1120,13 @@
+ * the palette.
+ */
+
+-/*For the moment 'png_init_palette_transformations' and
++/* For the moment 'png_init_palette_transformations' and
+ * 'png_init_rgb_transformations' only do some flag canceling optimizations.
+ * The intent is that these two routines should have palette or rgb operations
+ * extracted from 'png_init_read_transformations'.
+ */
+ static void /* PRIVATE */
+-png_init_palette_transformations(png_structp png_ptr)
++png_init_palette_transformations(png_structrp png_ptr)
+ {
+ /* Called to handle the (input) palette case. In png_do_read_transformations
+ * the first step is to expand the palette if requested, so this code must
+@@ -1116,25 +1145,31 @@
+
+ /* Ignore if all the entries are opaque (unlikely!) */
+ for (i=0; i<png_ptr->num_trans; ++i)
++ {
+ if (png_ptr->trans_alpha[i] == 255)
+ continue;
+ else if (png_ptr->trans_alpha[i] == 0)
+ input_has_transparency = 1;
+ else
++ {
++ input_has_transparency = 1;
+ input_has_alpha = 1;
++ break;
++ }
++ }
+ }
+
+ /* If no alpha we can optimize. */
+- if (!input_has_alpha)
++ if (input_has_alpha == 0)
+ {
+ /* Any alpha means background and associative alpha processing is
+- * required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA
++ * required, however if the alpha is 0 or 1 throughout OPTIMIZE_ALPHA
+ * and ENCODE_ALPHA are irrelevant.
+ */
+ png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
+ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
+
+- if (!input_has_transparency)
++ if (input_has_transparency == 0)
+ png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND);
+ }
+
+@@ -1147,8 +1182,8 @@
+ /* The following code cannot be entered in the alpha pre-multiplication case
+ * because PNG_BACKGROUND_EXPAND is cancelled below.
+ */
+- if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+- (png_ptr->transformations & PNG_EXPAND))
++ if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0 &&
++ (png_ptr->transformations & PNG_EXPAND) != 0)
+ {
+ {
+ png_ptr->background.red =
+@@ -1159,9 +1194,9 @@
+ png_ptr->palette[png_ptr->background.index].blue;
+
+ #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+- if (png_ptr->transformations & PNG_INVERT_ALPHA)
++ if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
+ {
+- if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
++ if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
+ {
+ /* Invert the alpha channel (in tRNS) unless the pixels are
+ * going to be expanded, in which case leave it for later
+@@ -1173,14 +1208,14 @@
+ png_ptr->trans_alpha[i]);
+ }
+ }
+-#endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */
++#endif /* READ_INVERT_ALPHA */
+ }
+ } /* background expand and (therefore) no alpha association. */
+-#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */
++#endif /* READ_EXPAND && READ_BACKGROUND */
+ }
+
+ static void /* PRIVATE */
+-png_init_rgb_transformations(png_structp png_ptr)
++png_init_rgb_transformations(png_structrp png_ptr)
+ {
+ /* Added to libpng-1.5.4: check the color type to determine whether there
+ * is any alpha or transparency in the image and simply cancel the
+@@ -1190,10 +1225,10 @@
+ int input_has_transparency = png_ptr->num_trans > 0;
+
+ /* If no alpha we can optimize. */
+- if (!input_has_alpha)
++ if (input_has_alpha == 0)
+ {
+ /* Any alpha means background and associative alpha processing is
+- * required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA
++ * required, however if the alpha is 0 or 1 throughout OPTIMIZE_ALPHA
+ * and ENCODE_ALPHA are irrelevant.
+ */
+ # ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+@@ -1201,7 +1236,7 @@
+ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
+ # endif
+
+- if (!input_has_transparency)
++ if (input_has_transparency == 0)
+ png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND);
+ }
+
+@@ -1214,67 +1249,58 @@
+ /* The following code cannot be entered in the alpha pre-multiplication case
+ * because PNG_BACKGROUND_EXPAND is cancelled below.
+ */
+- if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+- (png_ptr->transformations & PNG_EXPAND) &&
+- !(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
++ if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0 &&
++ (png_ptr->transformations & PNG_EXPAND) != 0 &&
++ (png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
+ /* i.e., GRAY or GRAY_ALPHA */
+ {
+ {
+ /* Expand background and tRNS chunks */
++ int gray = png_ptr->background.gray;
++ int trans_gray = png_ptr->trans_color.gray;
++
+ switch (png_ptr->bit_depth)
+ {
+ case 1:
+- png_ptr->background.gray *= (png_uint_16)0xff;
+- png_ptr->background.red = png_ptr->background.green
+- = png_ptr->background.blue = png_ptr->background.gray;
+- if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+- {
+- png_ptr->trans_color.gray *= (png_uint_16)0xff;
+- png_ptr->trans_color.red = png_ptr->trans_color.green
+- = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
+- }
++ gray *= 0xff;
++ trans_gray *= 0xff;
+ break;
+
+ case 2:
+- png_ptr->background.gray *= (png_uint_16)0x55;
+- png_ptr->background.red = png_ptr->background.green
+- = png_ptr->background.blue = png_ptr->background.gray;
+- if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+- {
+- png_ptr->trans_color.gray *= (png_uint_16)0x55;
+- png_ptr->trans_color.red = png_ptr->trans_color.green
+- = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
+- }
++ gray *= 0x55;
++ trans_gray *= 0x55;
+ break;
+
+ case 4:
+- png_ptr->background.gray *= (png_uint_16)0x11;
+- png_ptr->background.red = png_ptr->background.green
+- = png_ptr->background.blue = png_ptr->background.gray;
+- if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
+- {
+- png_ptr->trans_color.gray *= (png_uint_16)0x11;
+- png_ptr->trans_color.red = png_ptr->trans_color.green
+- = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
+- }
++ gray *= 0x11;
++ trans_gray *= 0x11;
+ break;
+
+ default:
+
+ case 8:
++ /* FALL THROUGH (Already 8 bits) */
+
+ case 16:
+- png_ptr->background.red = png_ptr->background.green
+- = png_ptr->background.blue = png_ptr->background.gray;
++ /* Already a full 16 bits */
+ break;
+ }
++
++ png_ptr->background.red = png_ptr->background.green =
++ png_ptr->background.blue = (png_uint_16)gray;
++
++ if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
++ {
++ png_ptr->trans_color.red = png_ptr->trans_color.green =
++ png_ptr->trans_color.blue = (png_uint_16)trans_gray;
++ }
+ }
+ } /* background expand and (therefore) no alpha association. */
+-#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */
++#endif /* READ_EXPAND && READ_BACKGROUND */
+ }
+
+ void /* PRIVATE */
+-png_init_read_transformations(png_structp png_ptr)
++png_init_read_transformations(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_init_read_transformations");
+
+@@ -1299,17 +1325,17 @@
+ */
+ int gamma_correction = 0;
+
+- if (png_ptr->gamma != 0) /* has been set */
++ if (png_ptr->colorspace.gamma != 0) /* has been set */
+ {
+ if (png_ptr->screen_gamma != 0) /* screen set too */
+- gamma_correction = png_gamma_threshold(png_ptr->gamma,
++ gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma,
+ png_ptr->screen_gamma);
+
+ else
+ /* Assume the output matches the input; a long time default behavior
+ * of libpng, although the standard has nothing to say about this.
+ */
+- png_ptr->screen_gamma = png_reciprocal(png_ptr->gamma);
++ png_ptr->screen_gamma = png_reciprocal(png_ptr->colorspace.gamma);
+ }
+
+ else if (png_ptr->screen_gamma != 0)
+@@ -1318,7 +1344,7 @@
+ * png_set_alpha_mode (even if the alpha handling mode isn't required
+ * or isn't changed from the default.)
+ */
+- png_ptr->gamma = png_reciprocal(png_ptr->screen_gamma);
++ png_ptr->colorspace.gamma = png_reciprocal(png_ptr->screen_gamma);
+
+ else /* neither are set */
+ /* Just in case the following prevents any processing - file and screen
+@@ -1326,7 +1352,10 @@
+ * third gamma value other than png_set_background with 'UNIQUE', and,
+ * prior to 1.5.4
+ */
+- png_ptr->screen_gamma = png_ptr->gamma = PNG_FP_1;
++ png_ptr->screen_gamma = png_ptr->colorspace.gamma = PNG_FP_1;
++
++ /* We have a gamma value now. */
++ png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
+
+ /* Now turn the gamma transformation on or off as appropriate. Notice
+ * that PNG_GAMMA just refers to the file->screen correction. Alpha
+@@ -1336,7 +1365,7 @@
+ * the code immediately below if the transform can be handled outside the
+ * row loop.
+ */
+- if (gamma_correction)
++ if (gamma_correction != 0)
+ png_ptr->transformations |= PNG_GAMMA;
+
+ else
+@@ -1345,7 +1374,7 @@
+ #endif
+
+ /* Certain transformations have the effect of preventing other
+- * transformations that happen afterward in png_do_read_transformations,
++ * transformations that happen afterward in png_do_read_transformations;
+ * resolve the interdependencies here. From the code of
+ * png_do_read_transformations the order is:
+ *
+@@ -1363,19 +1392,19 @@
+ * 12) PNG_EXPAND_16
+ * 13) PNG_GRAY_TO_RGB iff PNG_BACKGROUND_IS_GRAY
+ * 14) PNG_INVERT_MONO
+- * 15) PNG_SHIFT
+- * 16) PNG_PACK
+- * 17) PNG_BGR
+- * 18) PNG_PACKSWAP
+- * 19) PNG_FILLER (includes PNG_ADD_ALPHA)
+- * 20) PNG_INVERT_ALPHA
++ * 15) PNG_INVERT_ALPHA
++ * 16) PNG_SHIFT
++ * 17) PNG_PACK
++ * 18) PNG_BGR
++ * 19) PNG_PACKSWAP
++ * 20) PNG_FILLER (includes PNG_ADD_ALPHA)
+ * 21) PNG_SWAP_ALPHA
+ * 22) PNG_SWAP_BYTES
+ * 23) PNG_USER_TRANSFORM [must be last]
+ */
+ #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+- if ((png_ptr->transformations & PNG_STRIP_ALPHA) &&
+- !(png_ptr->transformations & PNG_COMPOSE))
++ if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
++ (png_ptr->transformations & PNG_COMPOSE) == 0)
+ {
+ /* Stripping the alpha channel happens immediately after the 'expand'
+ * transformations, before all other transformation, so it cancels out
+@@ -1401,16 +1430,23 @@
+ /* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA
+ * settings will have no effect.
+ */
+- if (!png_gamma_significant(png_ptr->screen_gamma))
++ if (png_gamma_significant(png_ptr->screen_gamma) == 0)
+ {
+ png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
+ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
+ }
+ #endif
+
+-#if defined(PNG_READ_EXPAND_SUPPORTED) && \
+- defined(PNG_READ_BACKGROUND_SUPPORTED) && \
+- defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
++#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
++ /* Make sure the coefficients for the rgb to gray conversion are set
++ * appropriately.
++ */
++ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
++ png_colorspace_set_rgb_coefficients(png_ptr);
++#endif
++
++#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
++#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
+ /* Detect gray background and attempt to enable optimization for
+ * gray --> RGB case.
+ *
+@@ -1426,23 +1462,23 @@
+ * png_set_background, along with the bit depth, then the code has a record
+ * of exactly what color space the background is currently in.
+ */
+- if (png_ptr->transformations & PNG_BACKGROUND_EXPAND)
++ if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0)
+ {
+ /* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if
+- * the file was greyscale the background value is gray.
++ * the file was grayscale the background value is gray.
+ */
+- if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
+ png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
+ }
+
+- else if (png_ptr->transformations & PNG_COMPOSE)
++ else if ((png_ptr->transformations & PNG_COMPOSE) != 0)
+ {
+ /* PNG_COMPOSE: png_set_background was called with need_expand false,
+ * so the color is in the color space of the output or png_set_alpha_mode
+ * was called and the color is black. Ignore RGB_TO_GRAY because that
+ * happens before GRAY_TO_RGB.
+ */
+- if (png_ptr->transformations & PNG_GRAY_TO_RGB)
++ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
+ {
+ if (png_ptr->background.red == png_ptr->background.green &&
+ png_ptr->background.red == png_ptr->background.blue)
+@@ -1452,7 +1488,8 @@
+ }
+ }
+ }
+-#endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED (etc) */
++#endif /* READ_EXPAND && READ_BACKGROUND */
++#endif /* READ_GRAY_TO_RGB */
+
+ /* For indexed PNG data (PNG_COLOR_TYPE_PALETTE) many of the transformations
+ * can be performed directly on the palette, and some (such as rgb to gray)
+@@ -1473,10 +1510,10 @@
+
+ #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
+ defined(PNG_READ_EXPAND_16_SUPPORTED)
+- if ((png_ptr->transformations & PNG_EXPAND_16) &&
+- (png_ptr->transformations & PNG_COMPOSE) &&
+- !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
+- png_ptr->bit_depth != 16)
++ if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
++ (png_ptr->transformations & PNG_COMPOSE) != 0 &&
++ (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
++ png_ptr->bit_depth != 16)
+ {
+ /* TODO: fix this. Because the expand_16 operation is after the compose
+ * handling the background color must be 8, not 16, bits deep, but the
+@@ -1488,14 +1525,36 @@
+ * NOTE: this discards the low 16 bits of the user supplied background
+ * color, but until expand_16 works properly there is no choice!
+ */
+-# define CHOP(x) (x)=((png_uint_16)(((png_uint_32)(x)*255+32895) >> 16))
++# define CHOP(x) (x)=((png_uint_16)PNG_DIV257(x))
+ CHOP(png_ptr->background.red);
+ CHOP(png_ptr->background.green);
+ CHOP(png_ptr->background.blue);
+ CHOP(png_ptr->background.gray);
+ # undef CHOP
+ }
+-#endif /* PNG_READ_BACKGROUND_SUPPORTED && PNG_READ_EXPAND_16_SUPPORTED */
++#endif /* READ_BACKGROUND && READ_EXPAND_16 */
++
++#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
++ (defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \
++ defined(PNG_READ_STRIP_16_TO_8_SUPPORTED))
++ if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) != 0 &&
++ (png_ptr->transformations & PNG_COMPOSE) != 0 &&
++ (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
++ png_ptr->bit_depth == 16)
++ {
++ /* On the other hand, if a 16-bit file is to be reduced to 8-bits per
++ * component this will also happen after PNG_COMPOSE and so the background
++ * color must be pre-expanded here.
++ *
++ * TODO: fix this too.
++ */
++ png_ptr->background.red = (png_uint_16)(png_ptr->background.red * 257);
++ png_ptr->background.green =
++ (png_uint_16)(png_ptr->background.green * 257);
++ png_ptr->background.blue = (png_uint_16)(png_ptr->background.blue * 257);
++ png_ptr->background.gray = (png_uint_16)(png_ptr->background.gray * 257);
++ }
++#endif
+
+ /* NOTE: below 'PNG_READ_ALPHA_MODE_SUPPORTED' is presumed to also enable the
+ * background support (see the comments in scripts/pnglibconf.dfa), this
+@@ -1524,27 +1583,36 @@
+ * file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the
+ * tables.
+ */
+- if ((png_ptr->transformations & PNG_GAMMA)
+- || ((png_ptr->transformations & PNG_RGB_TO_GRAY)
+- && (png_gamma_significant(png_ptr->gamma) ||
+- png_gamma_significant(png_ptr->screen_gamma)))
+- || ((png_ptr->transformations & PNG_COMPOSE)
+- && (png_gamma_significant(png_ptr->gamma)
+- || png_gamma_significant(png_ptr->screen_gamma)
++ if ((png_ptr->transformations & PNG_GAMMA) != 0 ||
++ ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0 &&
++ (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
++ png_gamma_significant(png_ptr->screen_gamma) != 0)) ||
++ ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
++ (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
++ png_gamma_significant(png_ptr->screen_gamma) != 0
+ # ifdef PNG_READ_BACKGROUND_SUPPORTED
+- || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE
+- && png_gamma_significant(png_ptr->background_gamma))
++ || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE &&
++ png_gamma_significant(png_ptr->background_gamma) != 0)
+ # endif
+- )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA)
+- && png_gamma_significant(png_ptr->screen_gamma))
+- )
++ )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
++ png_gamma_significant(png_ptr->screen_gamma) != 0))
+ {
+ png_build_gamma_table(png_ptr, png_ptr->bit_depth);
+
+ #ifdef PNG_READ_BACKGROUND_SUPPORTED
+- if (png_ptr->transformations & PNG_COMPOSE)
++ if ((png_ptr->transformations & PNG_COMPOSE) != 0)
+ {
+- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
++ /* Issue a warning about this combination: because RGB_TO_GRAY is
++ * optimized to do the gamma transform if present yet do_background has
++ * to do the same thing if both options are set a
++ * double-gamma-correction happens. This is true in all versions of
++ * libpng to date.
++ */
++ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
++ png_warning(png_ptr,
++ "libpng does not support gamma+background+rgb_to_gray");
++
++ if ((png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) != 0)
+ {
+ /* We don't get to here unless there is a tRNS chunk with non-opaque
+ * entries - see the checking code at the start of this function.
+@@ -1576,8 +1644,8 @@
+ break;
+
+ case PNG_BACKGROUND_GAMMA_FILE:
+- g = png_reciprocal(png_ptr->gamma);
+- gs = png_reciprocal2(png_ptr->gamma,
++ g = png_reciprocal(png_ptr->colorspace.gamma);
++ gs = png_reciprocal2(png_ptr->colorspace.gamma,
+ png_ptr->screen_gamma);
+ break;
+
+@@ -1592,7 +1660,7 @@
+ break;
+ }
+
+- if (png_gamma_significant(gs))
++ if (png_gamma_significant(gs) != 0)
+ {
+ back.red = png_gamma_8bit_correct(png_ptr->background.red,
+ gs);
+@@ -1609,7 +1677,7 @@
+ back.blue = (png_byte)png_ptr->background.blue;
+ }
+
+- if (png_gamma_significant(g))
++ if (png_gamma_significant(g) != 0)
+ {
+ back_1.red = png_gamma_8bit_correct(png_ptr->background.red,
+ g);
+@@ -1663,7 +1731,7 @@
+
+ /* Prevent the transformations being done again.
+ *
+- * NOTE: this is highly dubious; it zaps the transformations in
++ * NOTE: this is highly dubious; it removes the transformations in
+ * place. This seems inconsistent with the general treatment of the
+ * transformations elsewhere.
+ */
+@@ -1673,8 +1741,9 @@
+ /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
+ else /* color_type != PNG_COLOR_TYPE_PALETTE */
+ {
+- png_fixed_point g = PNG_FP_1;
+- png_fixed_point gs = PNG_FP_1;
++ int gs_sig, g_sig;
++ png_fixed_point g = PNG_FP_1; /* Correction to linear */
++ png_fixed_point gs = PNG_FP_1; /* Correction to screen */
+
+ switch (png_ptr->background_gamma_type)
+ {
+@@ -1684,8 +1753,9 @@
+ break;
+
+ case PNG_BACKGROUND_GAMMA_FILE:
+- g = png_reciprocal(png_ptr->gamma);
+- gs = png_reciprocal2(png_ptr->gamma, png_ptr->screen_gamma);
++ g = png_reciprocal(png_ptr->colorspace.gamma);
++ gs = png_reciprocal2(png_ptr->colorspace.gamma,
++ png_ptr->screen_gamma);
+ break;
+
+ case PNG_BACKGROUND_GAMMA_UNIQUE:
+@@ -1698,34 +1768,45 @@
+ png_error(png_ptr, "invalid background gamma type");
+ }
+
+- png_ptr->background_1.gray = png_gamma_correct(png_ptr,
+- png_ptr->background.gray, g);
+-
+- png_ptr->background.gray = png_gamma_correct(png_ptr,
+- png_ptr->background.gray, gs);
++ g_sig = png_gamma_significant(g);
++ gs_sig = png_gamma_significant(gs);
++
++ if (g_sig != 0)
++ png_ptr->background_1.gray = png_gamma_correct(png_ptr,
++ png_ptr->background.gray, g);
++
++ if (gs_sig != 0)
++ png_ptr->background.gray = png_gamma_correct(png_ptr,
++ png_ptr->background.gray, gs);
+
+ if ((png_ptr->background.red != png_ptr->background.green) ||
+ (png_ptr->background.red != png_ptr->background.blue) ||
+ (png_ptr->background.red != png_ptr->background.gray))
+ {
+ /* RGB or RGBA with color background */
+- png_ptr->background_1.red = png_gamma_correct(png_ptr,
+- png_ptr->background.red, g);
+-
+- png_ptr->background_1.green = png_gamma_correct(png_ptr,
+- png_ptr->background.green, g);
+-
+- png_ptr->background_1.blue = png_gamma_correct(png_ptr,
+- png_ptr->background.blue, g);
+-
+- png_ptr->background.red = png_gamma_correct(png_ptr,
+- png_ptr->background.red, gs);
+-
+- png_ptr->background.green = png_gamma_correct(png_ptr,
+- png_ptr->background.green, gs);
+-
+- png_ptr->background.blue = png_gamma_correct(png_ptr,
+- png_ptr->background.blue, gs);
++ if (g_sig != 0)
++ {
++ png_ptr->background_1.red = png_gamma_correct(png_ptr,
++ png_ptr->background.red, g);
++
++ png_ptr->background_1.green = png_gamma_correct(png_ptr,
++ png_ptr->background.green, g);
++
++ png_ptr->background_1.blue = png_gamma_correct(png_ptr,
++ png_ptr->background.blue, g);
++ }
++
++ if (gs_sig != 0)
++ {
++ png_ptr->background.red = png_gamma_correct(png_ptr,
++ png_ptr->background.red, gs);
++
++ png_ptr->background.green = png_gamma_correct(png_ptr,
++ png_ptr->background.green, gs);
++
++ png_ptr->background.blue = png_gamma_correct(png_ptr,
++ png_ptr->background.blue, gs);
++ }
+ }
+
+ else
+@@ -1737,20 +1818,29 @@
+ png_ptr->background.red = png_ptr->background.green
+ = png_ptr->background.blue = png_ptr->background.gray;
+ }
++
++ /* The background is now in screen gamma: */
++ png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_SCREEN;
+ } /* color_type != PNG_COLOR_TYPE_PALETTE */
+ }/* png_ptr->transformations & PNG_BACKGROUND */
+
+ else
+ /* Transformation does not include PNG_BACKGROUND */
+-#endif /* PNG_READ_BACKGROUND_SUPPORTED */
+- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
++#endif /* READ_BACKGROUND */
++ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE
++#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
++ /* RGB_TO_GRAY needs to have non-gamma-corrected values! */
++ && ((png_ptr->transformations & PNG_EXPAND) == 0 ||
++ (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
++#endif
++ )
+ {
+ png_colorp palette = png_ptr->palette;
+ int num_palette = png_ptr->num_palette;
+ int i;
+
+- /*NOTE: there are other transformations that should probably be in here
+- * too.
++ /* NOTE: there are other transformations that should probably be in
++ * here too.
+ */
+ for (i = 0; i < num_palette; i++)
+ {
+@@ -1766,11 +1856,11 @@
+ #ifdef PNG_READ_BACKGROUND_SUPPORTED
+ else
+ #endif
+-#endif /* PNG_READ_GAMMA_SUPPORTED */
++#endif /* READ_GAMMA */
+
+ #ifdef PNG_READ_BACKGROUND_SUPPORTED
+ /* No GAMMA transformation (see the hanging else 4 lines above) */
+- if ((png_ptr->transformations & PNG_COMPOSE) &&
++ if ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
+ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
+ {
+ int i;
+@@ -1805,35 +1895,53 @@
+
+ png_ptr->transformations &= ~PNG_COMPOSE;
+ }
+-#endif /* PNG_READ_BACKGROUND_SUPPORTED */
++#endif /* READ_BACKGROUND */
+
+ #ifdef PNG_READ_SHIFT_SUPPORTED
+- if ((png_ptr->transformations & PNG_SHIFT) &&
++ if ((png_ptr->transformations & PNG_SHIFT) != 0 &&
++ (png_ptr->transformations & PNG_EXPAND) == 0 &&
+ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
+ {
+- png_uint_16 i;
+- png_uint_16 istop = png_ptr->num_palette;
+- int sr = 8 - png_ptr->sig_bit.red;
+- int sg = 8 - png_ptr->sig_bit.green;
+- int sb = 8 - png_ptr->sig_bit.blue;
+-
+- if (sr < 0 || sr > 8)
+- sr = 0;
+-
+- if (sg < 0 || sg > 8)
+- sg = 0;
+-
+- if (sb < 0 || sb > 8)
+- sb = 0;
+-
+- for (i = 0; i < istop; i++)
+- {
+- png_ptr->palette[i].red >>= sr;
+- png_ptr->palette[i].green >>= sg;
+- png_ptr->palette[i].blue >>= sb;
+- }
++ int i;
++ int istop = png_ptr->num_palette;
++ int shift = 8 - png_ptr->sig_bit.red;
++
++ png_ptr->transformations &= ~PNG_SHIFT;
++
++ /* significant bits can be in the range 1 to 7 for a meaninful result, if
++ * the number of significant bits is 0 then no shift is done (this is an
++ * error condition which is silently ignored.)
++ */
++ if (shift > 0 && shift < 8)
++ for (i=0; i<istop; ++i)
++ {
++ int component = png_ptr->palette[i].red;
++
++ component >>= shift;
++ png_ptr->palette[i].red = (png_byte)component;
++ }
++
++ shift = 8 - png_ptr->sig_bit.green;
++ if (shift > 0 && shift < 8)
++ for (i=0; i<istop; ++i)
++ {
++ int component = png_ptr->palette[i].green;
++
++ component >>= shift;
++ png_ptr->palette[i].green = (png_byte)component;
++ }
++
++ shift = 8 - png_ptr->sig_bit.blue;
++ if (shift > 0 && shift < 8)
++ for (i=0; i<istop; ++i)
++ {
++ int component = png_ptr->palette[i].blue;
++
++ component >>= shift;
++ png_ptr->palette[i].blue = (png_byte)component;
++ }
+ }
+-#endif /* PNG_READ_SHIFT_SUPPORTED */
++#endif /* READ_SHIFT */
+ }
+
+ /* Modify the info structure to reflect the transformations. The
+@@ -1841,12 +1949,12 @@
+ * assuming the transformations result in valid PNG data.
+ */
+ void /* PRIVATE */
+-png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
++png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
+ {
+ png_debug(1, "in png_read_transform_info");
+
+ #ifdef PNG_READ_EXPAND_SUPPORTED
+- if (png_ptr->transformations & PNG_EXPAND)
++ if ((png_ptr->transformations & PNG_EXPAND) != 0)
+ {
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+@@ -1868,9 +1976,9 @@
+ }
+ else
+ {
+- if (png_ptr->num_trans)
++ if (png_ptr->num_trans != 0)
+ {
+- if (png_ptr->transformations & PNG_EXPAND_tRNS)
++ if ((png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
+ info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
+ }
+ if (info_ptr->bit_depth < 8)
+@@ -1886,7 +1994,7 @@
+ /* The following is almost certainly wrong unless the background value is in
+ * the screen space!
+ */
+- if (png_ptr->transformations & PNG_COMPOSE)
++ if ((png_ptr->transformations & PNG_COMPOSE) != 0)
+ info_ptr->background = png_ptr->background;
+ #endif
+
+@@ -1895,20 +2003,24 @@
+ * however it seems that the code in png_init_read_transformations, which has
+ * been called before this from png_read_update_info->png_read_start_row
+ * sometimes does the gamma transform and cancels the flag.
++ *
++ * TODO: this looks wrong; the info_ptr should end up with a gamma equal to
++ * the screen_gamma value. The following probably results in weirdness if
++ * the info_ptr is used by the app after the rows have been read.
+ */
+- info_ptr->gamma = png_ptr->gamma;
++ info_ptr->colorspace.gamma = png_ptr->colorspace.gamma;
+ #endif
+
+ if (info_ptr->bit_depth == 16)
+ {
+ # ifdef PNG_READ_16BIT_SUPPORTED
+ # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+- if (png_ptr->transformations & PNG_SCALE_16_TO_8)
++ if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
+ info_ptr->bit_depth = 8;
+ # endif
+
+ # ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+- if (png_ptr->transformations & PNG_16_TO_8)
++ if ((png_ptr->transformations & PNG_16_TO_8) != 0)
+ info_ptr->bit_depth = 8;
+ # endif
+
+@@ -1926,7 +2038,7 @@
+ info_ptr->bit_depth = 8;
+ # else
+
+-# if PNG_READ_SCALE_16_TO_8_SUPPORTED
++# ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+ png_ptr->transformations |= PNG_SCALE_16_TO_8;
+ info_ptr->bit_depth = 8;
+ # else
+@@ -1934,25 +2046,27 @@
+ CONFIGURATION ERROR: you must enable at least one 16 to 8 method
+ # endif
+ # endif
+-#endif /* !READ_16BIT_SUPPORTED */
++#endif /* !READ_16BIT */
+ }
+
+ #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+- if (png_ptr->transformations & PNG_GRAY_TO_RGB)
+- info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
++ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
++ info_ptr->color_type = (png_byte)(info_ptr->color_type |
++ PNG_COLOR_MASK_COLOR);
+ #endif
+
+ #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+- if (png_ptr->transformations & PNG_RGB_TO_GRAY)
+- info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
++ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
++ info_ptr->color_type = (png_byte)(info_ptr->color_type &
++ ~PNG_COLOR_MASK_COLOR);
+ #endif
+
+ #ifdef PNG_READ_QUANTIZE_SUPPORTED
+- if (png_ptr->transformations & PNG_QUANTIZE)
++ if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
+ {
+ if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
+- png_ptr->palette_lookup && info_ptr->bit_depth == 8)
++ png_ptr->palette_lookup != 0 && info_ptr->bit_depth == 8)
+ {
+ info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
+ }
+@@ -1960,54 +2074,57 @@
+ #endif
+
+ #ifdef PNG_READ_EXPAND_16_SUPPORTED
+- if (png_ptr->transformations & PNG_EXPAND_16 && info_ptr->bit_depth == 8 &&
+- info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
++ if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
++ info_ptr->bit_depth == 8 &&
++ info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+ {
+ info_ptr->bit_depth = 16;
+ }
+ #endif
+
+ #ifdef PNG_READ_PACK_SUPPORTED
+- if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
++ if ((png_ptr->transformations & PNG_PACK) != 0 &&
++ (info_ptr->bit_depth < 8))
+ info_ptr->bit_depth = 8;
+ #endif
+
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ info_ptr->channels = 1;
+
+- else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
++ else if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
+ info_ptr->channels = 3;
+
+ else
+ info_ptr->channels = 1;
+
+ #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+- if (png_ptr->transformations & PNG_STRIP_ALPHA)
++ if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0)
+ {
+- info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
++ info_ptr->color_type = (png_byte)(info_ptr->color_type &
++ ~PNG_COLOR_MASK_ALPHA);
+ info_ptr->num_trans = 0;
+ }
+ #endif
+
+- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
++ if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
+ info_ptr->channels++;
+
+ #ifdef PNG_READ_FILLER_SUPPORTED
+ /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */
+- if ((png_ptr->transformations & PNG_FILLER) &&
+- ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
+- (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
++ if ((png_ptr->transformations & PNG_FILLER) != 0 &&
++ (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
++ info_ptr->color_type == PNG_COLOR_TYPE_GRAY))
+ {
+ info_ptr->channels++;
+ /* If adding a true alpha channel not just filler */
+- if (png_ptr->transformations & PNG_ADD_ALPHA)
++ if ((png_ptr->transformations & PNG_ADD_ALPHA) != 0)
+ info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
+ }
+ #endif
+
+ #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
+ defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+- if (png_ptr->transformations & PNG_USER_TRANSFORM)
++ if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
+ {
+ if (info_ptr->bit_depth < png_ptr->user_transform_depth)
+ info_ptr->bit_depth = png_ptr->user_transform_depth;
+@@ -2031,291 +2148,11 @@
+ png_ptr->info_rowbytes = info_ptr->rowbytes;
+
+ #ifndef PNG_READ_EXPAND_SUPPORTED
+- if (png_ptr)
++ if (png_ptr != NULL)
+ return;
+ #endif
+ }
+
+-/* Transform the row. The order of transformations is significant,
+- * and is very touchy. If you add a transformation, take care to
+- * decide how it fits in with the other transformations here.
+- */
+-void /* PRIVATE */
+-png_do_read_transformations(png_structp png_ptr)
+-{
+- png_debug(1, "in png_do_read_transformations");
+-
+- if (png_ptr->row_buf == NULL)
+- {
+- /* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this
+- * error is incredibly rare and incredibly easy to debug without this
+- * information.
+- */
+- png_error(png_ptr, "NULL row buffer");
+- }
+-
+- /* The following is debugging; prior to 1.5.4 the code was never compiled in;
+- * in 1.5.4 PNG_FLAG_DETECT_UNINITIALIZED was added and the macro
+- * PNG_WARN_UNINITIALIZED_ROW removed. In 1.5 the new flag is set only for
+- * selected new APIs to ensure that there is no API change.
+- */
+- if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 &&
+- !(png_ptr->flags & PNG_FLAG_ROW_INIT))
+- {
+- /* Application has failed to call either png_read_start_image() or
+- * png_read_update_info() after setting transforms that expand pixels.
+- * This check added to libpng-1.2.19 (but not enabled until 1.5.4).
+- */
+- png_error(png_ptr, "Uninitialized row");
+- }
+-
+-#ifdef PNG_READ_EXPAND_SUPPORTED
+- if (png_ptr->transformations & PNG_EXPAND)
+- {
+- if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
+- {
+- png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
+- }
+-
+- else
+- {
+- if (png_ptr->num_trans &&
+- (png_ptr->transformations & PNG_EXPAND_tRNS))
+- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- &(png_ptr->trans_color));
+-
+- else
+- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- NULL);
+- }
+- }
+-#endif
+-
+-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+- if ((png_ptr->transformations & PNG_STRIP_ALPHA) &&
+- !(png_ptr->transformations & PNG_COMPOSE) &&
+- (png_ptr->row_info.color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
+- png_ptr->row_info.color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
+- png_do_strip_channel(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- 0 /* at_start == false, because SWAP_ALPHA happens later */);
+-#endif
+-
+-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+- if (png_ptr->transformations & PNG_RGB_TO_GRAY)
+- {
+- int rgb_error =
+- png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info),
+- png_ptr->row_buf + 1);
+-
+- if (rgb_error)
+- {
+- png_ptr->rgb_to_gray_status=1;
+- if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
+- PNG_RGB_TO_GRAY_WARN)
+- png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
+-
+- if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
+- PNG_RGB_TO_GRAY_ERR)
+- png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
+- }
+- }
+-#endif
+-
+-/* From Andreas Dilger e-mail to png-implement, 26 March 1998:
+- *
+- * In most cases, the "simple transparency" should be done prior to doing
+- * gray-to-RGB, or you will have to test 3x as many bytes to check if a
+- * pixel is transparent. You would also need to make sure that the
+- * transparency information is upgraded to RGB.
+- *
+- * To summarize, the current flow is:
+- * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
+- * with background "in place" if transparent,
+- * convert to RGB if necessary
+- * - Gray + alpha -> composite with gray background and remove alpha bytes,
+- * convert to RGB if necessary
+- *
+- * To support RGB backgrounds for gray images we need:
+- * - Gray + simple transparency -> convert to RGB + simple transparency,
+- * compare 3 or 6 bytes and composite with
+- * background "in place" if transparent
+- * (3x compare/pixel compared to doing
+- * composite with gray bkgrnd)
+- * - Gray + alpha -> convert to RGB + alpha, composite with background and
+- * remove alpha bytes (3x float
+- * operations/pixel compared with composite
+- * on gray background)
+- *
+- * Greg's change will do this. The reason it wasn't done before is for
+- * performance, as this increases the per-pixel operations. If we would check
+- * in advance if the background was gray or RGB, and position the gray-to-RGB
+- * transform appropriately, then it would save a lot of work/time.
+- */
+-
+-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+- /* If gray -> RGB, do so now only if background is non-gray; else do later
+- * for performance reasons
+- */
+- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+- !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
+- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#if (defined PNG_READ_BACKGROUND_SUPPORTED) ||\
+- (defined PNG_READ_ALPHA_MODE_SUPPORTED)
+- if (png_ptr->transformations & PNG_COMPOSE)
+- png_do_compose(&(png_ptr->row_info), png_ptr->row_buf + 1, png_ptr);
+-#endif
+-
+-#ifdef PNG_READ_GAMMA_SUPPORTED
+- if ((png_ptr->transformations & PNG_GAMMA) &&
+-#if (defined PNG_READ_BACKGROUND_SUPPORTED) ||\
+- (defined PNG_READ_ALPHA_MODE_SUPPORTED)
+- !((png_ptr->transformations & PNG_COMPOSE) &&
+- ((png_ptr->num_trans != 0) ||
+- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
+-#endif
+- (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
+- png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1, png_ptr);
+-#endif
+-
+-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+- if ((png_ptr->transformations & PNG_STRIP_ALPHA) &&
+- (png_ptr->transformations & PNG_COMPOSE) &&
+- (png_ptr->row_info.color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
+- png_ptr->row_info.color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
+- png_do_strip_channel(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- 0 /* at_start == false, because SWAP_ALPHA happens later */);
+-#endif
+-
+-#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+- if ((png_ptr->transformations & PNG_ENCODE_ALPHA) &&
+- (png_ptr->row_info.color_type & PNG_COLOR_MASK_ALPHA))
+- png_do_encode_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1, png_ptr);
+-#endif
+-
+-#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+- if (png_ptr->transformations & PNG_SCALE_16_TO_8)
+- png_do_scale_16_to_8(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+- /* There is no harm in doing both of these because only one has any effect,
+- * by putting the 'scale' option first if the app asks for scale (either by
+- * calling the API or in a TRANSFORM flag) this is what happens.
+- */
+- if (png_ptr->transformations & PNG_16_TO_8)
+- png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_QUANTIZE_SUPPORTED
+- if (png_ptr->transformations & PNG_QUANTIZE)
+- {
+- png_do_quantize(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- png_ptr->palette_lookup, png_ptr->quantize_index);
+-
+- if (png_ptr->row_info.rowbytes == 0)
+- png_error(png_ptr, "png_do_quantize returned rowbytes=0");
+- }
+-#endif /* PNG_READ_QUANTIZE_SUPPORTED */
+-
+-#ifdef PNG_READ_EXPAND_16_SUPPORTED
+- /* Do the expansion now, after all the arithmetic has been done. Notice
+- * that previous transformations can handle the PNG_EXPAND_16 flag if this
+- * is efficient (particularly true in the case of gamma correction, where
+- * better accuracy results faster!)
+- */
+- if (png_ptr->transformations & PNG_EXPAND_16)
+- png_do_expand_16(&png_ptr->row_info, png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+- /*NOTE: moved here in 1.5.4 (from much later in this list.) */
+- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
+- (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
+- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_INVERT_SUPPORTED
+- if (png_ptr->transformations & PNG_INVERT_MONO)
+- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_SHIFT_SUPPORTED
+- if (png_ptr->transformations & PNG_SHIFT)
+- png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- &(png_ptr->shift));
+-#endif
+-
+-#ifdef PNG_READ_PACK_SUPPORTED
+- if (png_ptr->transformations & PNG_PACK)
+- png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_BGR_SUPPORTED
+- if (png_ptr->transformations & PNG_BGR)
+- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_PACKSWAP_SUPPORTED
+- if (png_ptr->transformations & PNG_PACKSWAP)
+- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_FILLER_SUPPORTED
+- if (png_ptr->transformations & PNG_FILLER)
+- png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- (png_uint_32)png_ptr->filler, png_ptr->flags);
+-#endif
+-
+-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+- if (png_ptr->transformations & PNG_INVERT_ALPHA)
+- png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+- if (png_ptr->transformations & PNG_SWAP_ALPHA)
+- png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_READ_16BIT_SUPPORTED
+-#ifdef PNG_READ_SWAP_SUPPORTED
+- if (png_ptr->transformations & PNG_SWAP_BYTES)
+- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-#endif
+-
+-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+- if (png_ptr->transformations & PNG_USER_TRANSFORM)
+- {
+- if (png_ptr->read_user_transform_fn != NULL)
+- (*(png_ptr->read_user_transform_fn)) /* User read transform function */
+- (png_ptr, /* png_ptr */
+- &(png_ptr->row_info), /* row_info: */
+- /* png_uint_32 width; width of row */
+- /* png_size_t rowbytes; number of bytes in row */
+- /* png_byte color_type; color type of pixels */
+- /* png_byte bit_depth; bit depth of samples */
+- /* png_byte channels; number of channels (1-4) */
+- /* png_byte pixel_depth; bits per pixel (depth*channels) */
+- png_ptr->row_buf + 1); /* start of pixel data for row */
+-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+- if (png_ptr->user_transform_depth)
+- png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
+-
+- if (png_ptr->user_transform_channels)
+- png_ptr->row_info.channels = png_ptr->user_transform_channels;
+-#endif
+- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
+- png_ptr->row_info.channels);
+-
+- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+- png_ptr->row_info.width);
+- }
+-#endif
+-}
+-
+ #ifdef PNG_READ_PACK_SUPPORTED
+ /* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
+ * without changing the actual values. Thus, if you had a row with
+@@ -2323,7 +2160,7 @@
+ * the numbers 0 or 1. If you would rather they contain 0 and 255, use
+ * png_do_shift() after this.
+ */
+-void /* PRIVATE */
++static void
+ png_do_unpack(png_row_infop row_info, png_bytep row)
+ {
+ png_debug(1, "in png_do_unpack");
+@@ -2421,109 +2258,132 @@
+ * a row of bit depth 8, but only 5 are significant, this will shift
+ * the values back to 0 through 31.
+ */
+-void /* PRIVATE */
++static void
+ png_do_unshift(png_row_infop row_info, png_bytep row,
+ png_const_color_8p sig_bits)
+ {
++ int color_type;
++
+ png_debug(1, "in png_do_unshift");
+
+- if (
+- row_info->color_type != PNG_COLOR_TYPE_PALETTE)
++ /* The palette case has already been handled in the _init routine. */
++ color_type = row_info->color_type;
++
++ if (color_type != PNG_COLOR_TYPE_PALETTE)
+ {
+ int shift[4];
+ int channels = 0;
+- int c;
+- png_uint_16 value = 0;
+- png_uint_32 row_width = row_info->width;
+-
+- if (row_info->color_type & PNG_COLOR_MASK_COLOR)
++ int bit_depth = row_info->bit_depth;
++
++ if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+- shift[channels++] = row_info->bit_depth - sig_bits->red;
+- shift[channels++] = row_info->bit_depth - sig_bits->green;
+- shift[channels++] = row_info->bit_depth - sig_bits->blue;
++ shift[channels++] = bit_depth - sig_bits->red;
++ shift[channels++] = bit_depth - sig_bits->green;
++ shift[channels++] = bit_depth - sig_bits->blue;
+ }
+
+ else
+ {
+- shift[channels++] = row_info->bit_depth - sig_bits->gray;
++ shift[channels++] = bit_depth - sig_bits->gray;
+ }
+
+- if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
++ if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
+ {
+- shift[channels++] = row_info->bit_depth - sig_bits->alpha;
++ shift[channels++] = bit_depth - sig_bits->alpha;
+ }
+
+- for (c = 0; c < channels; c++)
+ {
+- if (shift[c] <= 0)
+- shift[c] = 0;
+-
+- else
+- value = 1;
++ int c, have_shift;
++
++ for (c = have_shift = 0; c < channels; ++c)
++ {
++ /* A shift of more than the bit depth is an error condition but it
++ * gets ignored here.
++ */
++ if (shift[c] <= 0 || shift[c] >= bit_depth)
++ shift[c] = 0;
++
++ else
++ have_shift = 1;
++ }
++
++ if (have_shift == 0)
++ return;
+ }
+
+- if (!value)
+- return;
+-
+- switch (row_info->bit_depth)
++ switch (bit_depth)
+ {
+ default:
++ /* Must be 1bpp gray: should not be here! */
++ /* NOTREACHED */
+ break;
+
+ case 2:
++ /* Must be 2bpp gray */
++ /* assert(channels == 1 && shift[0] == 1) */
+ {
+- png_bytep bp;
+- png_size_t i;
+- png_size_t istop = row_info->rowbytes;
+-
+- for (bp = row, i = 0; i < istop; i++)
++ png_bytep bp = row;
++ png_bytep bp_end = bp + row_info->rowbytes;
++
++ while (bp < bp_end)
+ {
+- *bp >>= 1;
+- *bp++ &= 0x55;
++ int b = (*bp >> 1) & 0x55;
++ *bp++ = (png_byte)b;
+ }
+ break;
+ }
+
+ case 4:
++ /* Must be 4bpp gray */
++ /* assert(channels == 1) */
+ {
+ png_bytep bp = row;
+- png_size_t i;
+- png_size_t istop = row_info->rowbytes;
+- png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |
+- (png_byte)((int)0xf >> shift[0]));
+-
+- for (i = 0; i < istop; i++)
++ png_bytep bp_end = bp + row_info->rowbytes;
++ int gray_shift = shift[0];
++ int mask = 0xf >> gray_shift;
++
++ mask |= mask << 4;
++
++ while (bp < bp_end)
+ {
+- *bp >>= shift[0];
+- *bp++ &= mask;
++ int b = (*bp >> gray_shift) & mask;
++ *bp++ = (png_byte)b;
+ }
+ break;
+ }
+
+ case 8:
++ /* Single byte components, G, GA, RGB, RGBA */
+ {
+ png_bytep bp = row;
+- png_uint_32 i;
+- png_uint_32 istop = row_width * channels;
+-
+- for (i = 0; i < istop; i++)
++ png_bytep bp_end = bp + row_info->rowbytes;
++ int channel = 0;
++
++ while (bp < bp_end)
+ {
+- *bp++ >>= shift[i%channels];
++ int b = *bp >> shift[channel];
++ if (++channel >= channels)
++ channel = 0;
++ *bp++ = (png_byte)b;
+ }
+ break;
+ }
+
+ #ifdef PNG_READ_16BIT_SUPPORTED
+ case 16:
++ /* Double byte components, G, GA, RGB, RGBA */
+ {
+ png_bytep bp = row;
+- png_uint_32 i;
+- png_uint_32 istop = channels * row_width;
+-
+- for (i = 0; i < istop; i++)
++ png_bytep bp_end = bp + row_info->rowbytes;
++ int channel = 0;
++
++ while (bp < bp_end)
+ {
+- value = (png_uint_16)((*bp << 8) + *(bp + 1));
+- value >>= shift[i%channels];
++ int value = (bp[0] << 8) + bp[1];
++
++ value >>= shift[channel];
++ if (++channel >= channels)
++ channel = 0;
+ *bp++ = (png_byte)(value >> 8);
+ *bp++ = (png_byte)(value & 0xff);
+ }
+@@ -2537,7 +2397,7 @@
+
+ #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+ /* Scale rows of bit depth 16 down to 8 accurately */
+-void /* PRIVATE */
++static void
+ png_do_scale_16_to_8(png_row_infop row_info, png_bytep row)
+ {
+ png_debug(1, "in png_do_scale_16_to_8");
+@@ -2545,7 +2405,7 @@
+ if (row_info->bit_depth == 16)
+ {
+ png_bytep sp = row; /* source */
+- png_bytep dp = row; /* destinaton */
++ png_bytep dp = row; /* destination */
+ png_bytep ep = sp + row_info->rowbytes; /* end+1 */
+
+ while (sp < ep)
+@@ -2595,7 +2455,7 @@
+ #endif
+
+ #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+-void /* PRIVATE */
++static void
+ /* Simply discard the low byte. This was the default behavior prior
+ * to libpng-1.5.4.
+ */
+@@ -2606,7 +2466,7 @@
+ if (row_info->bit_depth == 16)
+ {
+ png_bytep sp = row; /* source */
+- png_bytep dp = row; /* destinaton */
++ png_bytep dp = row; /* destination */
+ png_bytep ep = sp + row_info->rowbytes; /* end+1 */
+
+ while (sp < ep)
+@@ -2623,7 +2483,7 @@
+ #endif
+
+ #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+-void /* PRIVATE */
++static void
+ png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
+ {
+ png_debug(1, "in png_do_read_swap_alpha");
+@@ -2720,7 +2580,7 @@
+ #endif
+
+ #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+-void /* PRIVATE */
++static void
+ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
+ {
+ png_uint_32 row_width;
+@@ -2822,7 +2682,7 @@
+
+ #ifdef PNG_READ_FILLER_SUPPORTED
+ /* Add filler channel if we have RGB color */
+-void /* PRIVATE */
++static void
+ png_do_read_filler(png_row_infop row_info, png_bytep row,
+ png_uint_32 filler, png_uint_32 flags)
+ {
+@@ -2841,7 +2701,7 @@
+ {
+ if (row_info->bit_depth == 8)
+ {
+- if (flags & PNG_FLAG_FILLER_AFTER)
++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
+ {
+ /* This changes the data from G to GX */
+ png_bytep sp = row + (png_size_t)row_width;
+@@ -2876,7 +2736,7 @@
+ #ifdef PNG_READ_16BIT_SUPPORTED
+ else if (row_info->bit_depth == 16)
+ {
+- if (flags & PNG_FLAG_FILLER_AFTER)
++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
+ {
+ /* This changes the data from GG to GGXX */
+ png_bytep sp = row + (png_size_t)row_width * 2;
+@@ -2918,7 +2778,7 @@
+ {
+ if (row_info->bit_depth == 8)
+ {
+- if (flags & PNG_FLAG_FILLER_AFTER)
++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
+ {
+ /* This changes the data from RGB to RGBX */
+ png_bytep sp = row + (png_size_t)row_width * 3;
+@@ -2957,7 +2817,7 @@
+ #ifdef PNG_READ_16BIT_SUPPORTED
+ else if (row_info->bit_depth == 16)
+ {
+- if (flags & PNG_FLAG_FILLER_AFTER)
++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
+ {
+ /* This changes the data from RRGGBB to RRGGBBXX */
+ png_bytep sp = row + (png_size_t)row_width * 6;
+@@ -3009,7 +2869,7 @@
+
+ #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+ /* Expand grayscale files to RGB, with or without alpha */
+-void /* PRIVATE */
++static void
+ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
+ {
+ png_uint_32 i;
+@@ -3018,7 +2878,7 @@
+ png_debug(1, "in png_do_gray_to_rgb");
+
+ if (row_info->bit_depth >= 8 &&
+- !(row_info->color_type & PNG_COLOR_MASK_COLOR))
++ (row_info->color_type & PNG_COLOR_MASK_COLOR) == 0)
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+@@ -3086,7 +2946,7 @@
+ }
+ }
+ }
+- row_info->channels += (png_byte)2;
++ row_info->channels = (png_byte)(row_info->channels + 2);
+ row_info->color_type |= PNG_COLOR_MASK_COLOR;
+ row_info->pixel_depth = (png_byte)(row_info->channels *
+ row_info->bit_depth);
+@@ -3097,269 +2957,242 @@
+
+ #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+ /* Reduce RGB files to grayscale, with or without alpha
+- * using the equation given in Poynton's ColorFAQ at
+- * <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008)
+- * New link:
+- * <http://www.poynton.com/notes/colour_and_gamma/>
++ * using the equation given in Poynton's ColorFAQ of 1998-01-04 at
++ * <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008 but
++ * versions dated 1998 through November 2002 have been archived at
++ * http://web.archive.org/web/20000816232553/http://www.inforamp.net/
++ * ~poynton/notes/colour_and_gamma/ColorFAQ.txt )
+ * Charles Poynton poynton at poynton.com
+ *
+ * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B
+ *
+- * We approximate this with
+- *
+- * Y = 0.21268 * R + 0.7151 * G + 0.07217 * B
+- *
+ * which can be expressed with integers as
+ *
+ * Y = (6969 * R + 23434 * G + 2365 * B)/32768
+ *
+- * The calculation is to be done in a linear colorspace.
++ * Poynton's current link (as of January 2003 through July 2011):
++ * <http://www.poynton.com/notes/colour_and_gamma/>
++ * has changed the numbers slightly:
+ *
+- * Other integer coefficents can be used via png_set_rgb_to_gray().
++ * Y = 0.2126*R + 0.7152*G + 0.0722*B
++ *
++ * which can be expressed with integers as
++ *
++ * Y = (6966 * R + 23436 * G + 2366 * B)/32768
++ *
++ * Historically, however, libpng uses numbers derived from the ITU-R Rec 709
++ * end point chromaticities and the D65 white point. Depending on the
++ * precision used for the D65 white point this produces a variety of different
++ * numbers, however if the four decimal place value used in ITU-R Rec 709 is
++ * used (0.3127,0.3290) the Y calculation would be:
++ *
++ * Y = (6968 * R + 23435 * G + 2366 * B)/32768
++ *
++ * While this is correct the rounding results in an overflow for white, because
++ * the sum of the rounded coefficients is 32769, not 32768. Consequently
++ * libpng uses, instead, the closest non-overflowing approximation:
++ *
++ * Y = (6968 * R + 23434 * G + 2366 * B)/32768
++ *
++ * Starting with libpng-1.5.5, if the image being converted has a cHRM chunk
++ * (including an sRGB chunk) then the chromaticities are used to calculate the
++ * coefficients. See the chunk handling in pngrutil.c for more information.
++ *
++ * In all cases the calculation is to be done in a linear colorspace. If no
++ * gamma information is available to correct the encoding of the original RGB
++ * values this results in an implicit assumption that the original PNG RGB
++ * values were linear.
++ *
++ * Other integer coefficents can be used via png_set_rgb_to_gray(). Because
++ * the API takes just red and green coefficients the blue coefficient is
++ * calculated to make the sum 32768. This will result in different rounding
++ * to that used above.
+ */
+-int /* PRIVATE */
+-png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
++static int
++png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
+
+ {
+- png_uint_32 i;
+-
+- png_uint_32 row_width = row_info->width;
+ int rgb_error = 0;
+
+ png_debug(1, "in png_do_rgb_to_gray");
+
+- if (!(row_info->color_type & PNG_COLOR_MASK_PALETTE) &&
+- (row_info->color_type & PNG_COLOR_MASK_COLOR))
++ if ((row_info->color_type & PNG_COLOR_MASK_PALETTE) == 0 &&
++ (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+- png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
+- png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
+- png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
+-
+- if (row_info->color_type == PNG_COLOR_TYPE_RGB)
++ PNG_CONST png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
++ PNG_CONST png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
++ PNG_CONST png_uint_32 bc = 32768 - rc - gc;
++ PNG_CONST png_uint_32 row_width = row_info->width;
++ PNG_CONST int have_alpha =
++ (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0;
++
++ if (row_info->bit_depth == 8)
+ {
+- if (row_info->bit_depth == 8)
++#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
++ * the documentation, the original values must be checked.
++ */
++ if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
+ {
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+- if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
++ png_bytep sp = row;
++ png_bytep dp = row;
++ png_uint_32 i;
++
++ for (i = 0; i < row_width; i++)
+ {
+- png_bytep sp = row;
+- png_bytep dp = row;
+-
+- for (i = 0; i < row_width; i++)
++ png_byte red = *(sp++);
++ png_byte green = *(sp++);
++ png_byte blue = *(sp++);
++
++ if (red != green || red != blue)
+ {
+- png_byte red = png_ptr->gamma_to_1[*(sp++)];
+- png_byte green = png_ptr->gamma_to_1[*(sp++)];
+- png_byte blue = png_ptr->gamma_to_1[*(sp++)];
+-
+- if (red != green || red != blue)
+- {
+- rgb_error |= 1;
+- *(dp++) = png_ptr->gamma_from_1[
+- (rc*red + gc*green + bc*blue)>>15];
+- }
++ red = png_ptr->gamma_to_1[red];
++ green = png_ptr->gamma_to_1[green];
++ blue = png_ptr->gamma_to_1[blue];
++
++ rgb_error |= 1;
++ *(dp++) = png_ptr->gamma_from_1[
++ (rc*red + gc*green + bc*blue + 16384)>>15];
++ }
++
++ else
++ {
++ /* If there is no overall correction the table will not be
++ * set.
++ */
++ if (png_ptr->gamma_table != NULL)
++ red = png_ptr->gamma_table[red];
++
++ *(dp++) = red;
++ }
++
++ if (have_alpha != 0)
++ *(dp++) = *(sp++);
++ }
++ }
++ else
++#endif
++ {
++ png_bytep sp = row;
++ png_bytep dp = row;
++ png_uint_32 i;
++
++ for (i = 0; i < row_width; i++)
++ {
++ png_byte red = *(sp++);
++ png_byte green = *(sp++);
++ png_byte blue = *(sp++);
++
++ if (red != green || red != blue)
++ {
++ rgb_error |= 1;
++ /* NOTE: this is the historical approach which simply
++ * truncates the results.
++ */
++ *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
++ }
++
++ else
++ *(dp++) = red;
++
++ if (have_alpha != 0)
++ *(dp++) = *(sp++);
++ }
++ }
++ }
++
++ else /* RGB bit_depth == 16 */
++ {
++#ifdef PNG_READ_GAMMA_SUPPORTED
++ if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_1 != NULL)
++ {
++ png_bytep sp = row;
++ png_bytep dp = row;
++ png_uint_32 i;
++
++ for (i = 0; i < row_width; i++)
++ {
++ png_uint_16 red, green, blue, w;
++
++ red = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
++ green = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
++ blue = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
++
++ if (red == green && red == blue)
++ {
++ if (png_ptr->gamma_16_table != NULL)
++ w = png_ptr->gamma_16_table[(red & 0xff)
++ >> png_ptr->gamma_shift][red >> 8];
+
+ else
+- *(dp++) = *(sp - 1);
++ w = red;
+ }
+- }
+- else
+-#endif
+- {
+- png_bytep sp = row;
+- png_bytep dp = row;
+- for (i = 0; i < row_width; i++)
++
++ else
+ {
+- png_byte red = *(sp++);
+- png_byte green = *(sp++);
+- png_byte blue = *(sp++);
+-
+- if (red != green || red != blue)
+- {
+- rgb_error |= 1;
+- *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
+- }
+-
+- else
+- *(dp++) = *(sp - 1);
++ png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff)
++ >> png_ptr->gamma_shift][red>>8];
++ png_uint_16 green_1 =
++ png_ptr->gamma_16_to_1[(green&0xff) >>
++ png_ptr->gamma_shift][green>>8];
++ png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff)
++ >> png_ptr->gamma_shift][blue>>8];
++ png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1
++ + bc*blue_1 + 16384)>>15);
++ w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
++ png_ptr->gamma_shift][gray16 >> 8];
++ rgb_error |= 1;
++ }
++
++ *(dp++) = (png_byte)((w>>8) & 0xff);
++ *(dp++) = (png_byte)(w & 0xff);
++
++ if (have_alpha != 0)
++ {
++ *(dp++) = *(sp++);
++ *(dp++) = *(sp++);
+ }
+ }
+ }
+-
+- else /* RGB bit_depth == 16 */
++ else
++#endif
+ {
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+- if (png_ptr->gamma_16_to_1 != NULL &&
+- png_ptr->gamma_16_from_1 != NULL)
++ png_bytep sp = row;
++ png_bytep dp = row;
++ png_uint_32 i;
++
++ for (i = 0; i < row_width; i++)
+ {
+- png_bytep sp = row;
+- png_bytep dp = row;
+- for (i = 0; i < row_width; i++)
++ png_uint_16 red, green, blue, gray16;
++
++ red = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
++ green = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
++ blue = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
++
++ if (red != green || red != blue)
++ rgb_error |= 1;
++
++ /* From 1.5.5 in the 16 bit case do the accurate conversion even
++ * in the 'fast' case - this is because this is where the code
++ * ends up when handling linear 16 bit data.
++ */
++ gray16 = (png_uint_16)((rc*red + gc*green + bc*blue + 16384) >>
++ 15);
++ *(dp++) = (png_byte)((gray16 >> 8) & 0xff);
++ *(dp++) = (png_byte)(gray16 & 0xff);
++
++ if (have_alpha != 0)
+ {
+- png_uint_16 red, green, blue, w;
+-
+- red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+- green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+- blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+-
+- if (red == green && red == blue)
+- w = red;
+-
+- else
+- {
+- png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff)
+- >> png_ptr->gamma_shift][red>>8];
+- png_uint_16 green_1 =
+- png_ptr->gamma_16_to_1[(green&0xff) >>
+- png_ptr->gamma_shift][green>>8];
+- png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff)
+- >> png_ptr->gamma_shift][blue>>8];
+- png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1
+- + bc*blue_1)>>15);
+- w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
+- png_ptr->gamma_shift][gray16 >> 8];
+- rgb_error |= 1;
+- }
+-
+- *(dp++) = (png_byte)((w>>8) & 0xff);
+- *(dp++) = (png_byte)(w & 0xff);
+- }
+- }
+- else
+-#endif
+- {
+- png_bytep sp = row;
+- png_bytep dp = row;
+- for (i = 0; i < row_width; i++)
+- {
+- png_uint_16 red, green, blue, gray16;
+-
+- red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+- green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+- blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+-
+- if (red != green || red != blue)
+- rgb_error |= 1;
+-
+- gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
+- *(dp++) = (png_byte)((gray16>>8) & 0xff);
+- *(dp++) = (png_byte)(gray16 & 0xff);
+- }
+- }
+- }
+- }
+- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+- {
+- if (row_info->bit_depth == 8)
+- {
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+- if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
+- {
+- png_bytep sp = row;
+- png_bytep dp = row;
+- for (i = 0; i < row_width; i++)
+- {
+- png_byte red = png_ptr->gamma_to_1[*(sp++)];
+- png_byte green = png_ptr->gamma_to_1[*(sp++)];
+- png_byte blue = png_ptr->gamma_to_1[*(sp++)];
+-
+- if (red != green || red != blue)
+- rgb_error |= 1;
+-
+- *(dp++) = png_ptr->gamma_from_1
+- [(rc*red + gc*green + bc*blue)>>15];
+-
+- *(dp++) = *(sp++); /* alpha */
+- }
+- }
+- else
+-#endif
+- {
+- png_bytep sp = row;
+- png_bytep dp = row;
+- for (i = 0; i < row_width; i++)
+- {
+- png_byte red = *(sp++);
+- png_byte green = *(sp++);
+- png_byte blue = *(sp++);
+- if (red != green || red != blue)
+- rgb_error |= 1;
+-
+- *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
+- *(dp++) = *(sp++); /* alpha */
+- }
+- }
+- }
+- else /* RGBA bit_depth == 16 */
+- {
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+- if (png_ptr->gamma_16_to_1 != NULL &&
+- png_ptr->gamma_16_from_1 != NULL)
+- {
+- png_bytep sp = row;
+- png_bytep dp = row;
+- for (i = 0; i < row_width; i++)
+- {
+- png_uint_16 red, green, blue, w;
+-
+- red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+- green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+- blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2;
+-
+- if (red == green && red == blue)
+- w = red;
+-
+- else
+- {
+- png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>
+- png_ptr->gamma_shift][red>>8];
+-
+- png_uint_16 green_1 =
+- png_ptr->gamma_16_to_1[(green&0xff) >>
+- png_ptr->gamma_shift][green>>8];
+-
+- png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>
+- png_ptr->gamma_shift][blue>>8];
+-
+- png_uint_16 gray16 = (png_uint_16)((rc * red_1
+- + gc * green_1 + bc * blue_1)>>15);
+-
+- w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
+- png_ptr->gamma_shift][gray16 >> 8];
+-
+- rgb_error |= 1;
+- }
+-
+- *(dp++) = (png_byte)((w>>8) & 0xff);
+- *(dp++) = (png_byte)(w & 0xff);
+- *(dp++) = *(sp++); /* alpha */
+ *(dp++) = *(sp++);
+- }
+- }
+- else
+-#endif
+- {
+- png_bytep sp = row;
+- png_bytep dp = row;
+- for (i = 0; i < row_width; i++)
+- {
+- png_uint_16 red, green, blue, gray16;
+- red = (png_uint_16)((*(sp)<<8) | *(sp + 1)); sp += 2;
+- green = (png_uint_16)((*(sp)<<8) | *(sp + 1)); sp += 2;
+- blue = (png_uint_16)((*(sp)<<8) | *(sp + 1)); sp += 2;
+-
+- if (red != green || red != blue)
+- rgb_error |= 1;
+-
+- gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
+- *(dp++) = (png_byte)((gray16>>8) & 0xff);
+- *(dp++) = (png_byte)(gray16 & 0xff);
+- *(dp++) = *(sp++); /* alpha */
+ *(dp++) = *(sp++);
+ }
+ }
+ }
+ }
+- row_info->channels -= 2;
++
++ row_info->channels = (png_byte)(row_info->channels - 2);
+ row_info->color_type = (png_byte)(row_info->color_type &
+ ~PNG_COLOR_MASK_COLOR);
+ row_info->pixel_depth = (png_byte)(row_info->channels *
+@@ -3369,73 +3202,15 @@
+ return rgb_error;
+ }
+ #endif
+-#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+-
+-#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
+-/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
+- * large of png_color. This lets grayscale images be treated as
+- * paletted. Most useful for gamma correction and simplification
+- * of code. This API is not used internally.
+- */
+-void PNGAPI
+-png_build_grayscale_palette(int bit_depth, png_colorp palette)
+-{
+- int num_palette;
+- int color_inc;
+- int i;
+- int v;
+-
+- png_debug(1, "in png_do_build_grayscale_palette");
+-
+- if (palette == NULL)
+- return;
+-
+- switch (bit_depth)
+- {
+- case 1:
+- num_palette = 2;
+- color_inc = 0xff;
+- break;
+-
+- case 2:
+- num_palette = 4;
+- color_inc = 0x55;
+- break;
+-
+- case 4:
+- num_palette = 16;
+- color_inc = 0x11;
+- break;
+-
+- case 8:
+- num_palette = 256;
+- color_inc = 1;
+- break;
+-
+- default:
+- num_palette = 0;
+- color_inc = 0;
+- break;
+- }
+-
+- for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
+- {
+- palette[i].red = (png_byte)v;
+- palette[i].green = (png_byte)v;
+- palette[i].blue = (png_byte)v;
+- }
+-}
+-#endif
+-
+-
+-#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+-#ifdef PNG_READ_BACKGROUND_SUPPORTED
++
++#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
++ defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+ /* Replace any alpha or transparency with the supplied background color.
+ * "background" is already in the screen gamma, while "background_1" is
+ * at a gamma of 1.0. Paletted files have already been taken care of.
+ */
+-void /* PRIVATE */
+-png_do_compose(png_row_infop row_info, png_bytep row, png_structp png_ptr)
++static void
++png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
+ {
+ #ifdef PNG_READ_GAMMA_SUPPORTED
+ png_const_bytep gamma_table = png_ptr->gamma_table;
+@@ -3445,12 +3220,12 @@
+ 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");
+@@ -3471,11 +3246,12 @@
+ if ((png_uint_16)((*sp >> shift) & 0x01)
+ == png_ptr->trans_color.gray)
+ {
+- *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
+- *sp |= (png_byte)(png_ptr->background.gray << shift);
++ unsigned int tmp = *sp & (0x7f7f >> (7 - shift));
++ tmp |= png_ptr->background.gray << shift;
++ *sp = (png_byte)(tmp & 0xff);
+ }
+
+- if (!shift)
++ if (shift == 0)
+ {
+ shift = 7;
+ sp++;
+@@ -3499,20 +3275,22 @@
+ if ((png_uint_16)((*sp >> shift) & 0x03)
+ == png_ptr->trans_color.gray)
+ {
+- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+- *sp |= (png_byte)(png_ptr->background.gray << shift);
++ unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
++ tmp |= png_ptr->background.gray << shift;
++ *sp = (png_byte)(tmp & 0xff);
+ }
+
+ else
+ {
+- png_byte p = (png_byte)((*sp >> shift) & 0x03);
+- png_byte g = (png_byte)((gamma_table [p | (p << 2) |
+- (p << 4) | (p << 6)] >> 6) & 0x03);
+- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+- *sp |= (png_byte)(g << shift);
++ unsigned int p = (*sp >> shift) & 0x03;
++ unsigned int g = (gamma_table [p | (p << 2) |
++ (p << 4) | (p << 6)] >> 6) & 0x03;
++ unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
++ tmp |= g << shift;
++ *sp = (png_byte)(tmp & 0xff);
+ }
+
+- if (!shift)
++ if (shift == 0)
+ {
+ shift = 6;
+ sp++;
+@@ -3533,11 +3311,12 @@
+ if ((png_uint_16)((*sp >> shift) & 0x03)
+ == png_ptr->trans_color.gray)
+ {
+- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+- *sp |= (png_byte)(png_ptr->background.gray << shift);
++ unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
++ tmp |= png_ptr->background.gray << shift;
++ *sp = (png_byte)(tmp & 0xff);
+ }
+
+- if (!shift)
++ if (shift == 0)
+ {
+ shift = 6;
+ sp++;
+@@ -3562,20 +3341,22 @@
+ if ((png_uint_16)((*sp >> shift) & 0x0f)
+ == png_ptr->trans_color.gray)
+ {
+- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+- *sp |= (png_byte)(png_ptr->background.gray << shift);
++ unsigned int tmp = *sp & (0xf0f >> (4 - shift));
++ tmp |= png_ptr->background.gray << shift;
++ *sp = (png_byte)(tmp & 0xff);
+ }
+
+ else
+ {
+- png_byte p = (png_byte)((*sp >> shift) & 0x0f);
+- png_byte g = (png_byte)((gamma_table[p |
+- (p << 4)] >> 4) & 0x0f);
+- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+- *sp |= (png_byte)(g << shift);
++ unsigned int p = (*sp >> shift) & 0x0f;
++ unsigned int g = (gamma_table[p | (p << 4)] >> 4) &
++ 0x0f;
++ unsigned int tmp = *sp & (0xf0f >> (4 - shift));
++ tmp |= g << shift;
++ *sp = (png_byte)(tmp & 0xff);
+ }
+
+- if (!shift)
++ if (shift == 0)
+ {
+ shift = 4;
+ sp++;
+@@ -3596,11 +3377,12 @@
+ if ((png_uint_16)((*sp >> shift) & 0x0f)
+ == png_ptr->trans_color.gray)
+ {
+- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+- *sp |= (png_byte)(png_ptr->background.gray << shift);
++ unsigned int tmp = *sp & (0xf0f >> (4 - shift));
++ tmp |= png_ptr->background.gray << shift;
++ *sp = (png_byte)(tmp & 0xff);
+ }
+
+- if (!shift)
++ if (shift == 0)
+ {
+ shift = 4;
+ sp++;
+@@ -3656,8 +3438,10 @@
+ if (v == png_ptr->trans_color.gray)
+ {
+ /* Background is already in screen gamma */
+- *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff);
+- *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
++ *sp = (png_byte)((png_ptr->background.gray >> 8)
++ & 0xff);
++ *(sp + 1) = (png_byte)(png_ptr->background.gray
++ & 0xff);
+ }
+
+ else
+@@ -3680,8 +3464,10 @@
+
+ if (v == png_ptr->trans_color.gray)
+ {
+- *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff);
+- *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
++ *sp = (png_byte)((png_ptr->background.gray >> 8)
++ & 0xff);
++ *(sp + 1) = (png_byte)(png_ptr->background.gray
++ & 0xff);
+ }
+ }
+ }
+@@ -3761,9 +3547,12 @@
+ /* Background is already in screen gamma */
+ *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+- *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff);
+- *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff);
+- *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff);
++ *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
++ & 0xff);
++ *(sp + 3) = (png_byte)(png_ptr->background.green
++ & 0xff);
++ *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
++ & 0xff);
+ *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+ }
+
+@@ -3804,9 +3593,12 @@
+ {
+ *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+- *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff);
+- *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff);
+- *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff);
++ *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
++ & 0xff);
++ *(sp + 3) = (png_byte)(png_ptr->background.green
++ & 0xff);
++ *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
++ & 0xff);
+ *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+ }
+ }
+@@ -3843,7 +3635,7 @@
+
+ v = gamma_to_1[*sp];
+ png_composite(w, v, a, png_ptr->background_1.gray);
+- if (!optimize)
++ if (optimize == 0)
+ w = gamma_from_1[w];
+ *sp = w;
+ }
+@@ -3861,7 +3653,7 @@
+ *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);
+ }
+ }
+ }
+@@ -3889,7 +3681,8 @@
+ else if (a == 0)
+ {
+ /* Background is already in screen gamma */
+- *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff);
++ *sp = (png_byte)((png_ptr->background.gray >> 8)
++ & 0xff);
+ *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
+ }
+
+@@ -3899,7 +3692,7 @@
+
+ g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+ png_composite_16(v, g, a, png_ptr->background_1.gray);
+- if (optimize)
++ if (optimize != 0)
+ w = v;
+ else
+ w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];
+@@ -3919,7 +3712,8 @@
+
+ if (a == 0)
+ {
+- *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff);
++ *sp = (png_byte)((png_ptr->background.gray >> 8)
++ & 0xff);
+ *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
+ }
+
+@@ -3928,7 +3722,7 @@
+ 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);
+ }
+@@ -3972,17 +3766,17 @@
+
+ v = gamma_to_1[*sp];
+ png_composite(w, v, a, png_ptr->background_1.red);
+- if (!optimize) w = gamma_from_1[w];
++ if (optimize == 0) w = gamma_from_1[w];
+ *sp = w;
+
+ v = gamma_to_1[*(sp + 1)];
+ png_composite(w, v, a, png_ptr->background_1.green);
+- if (!optimize) w = gamma_from_1[w];
++ if (optimize == 0) w = gamma_from_1[w];
+ *(sp + 1) = w;
+
+ v = gamma_to_1[*(sp + 2)];
+ png_composite(w, v, a, png_ptr->background_1.blue);
+- if (!optimize) w = gamma_from_1[w];
++ if (optimize == 0) w = gamma_from_1[w];
+ *(sp + 2) = w;
+ }
+ }
+@@ -4049,9 +3843,12 @@
+ /* Background is already in screen gamma */
+ *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+- *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff);
+- *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff);
+- *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff);
++ *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
++ & 0xff);
++ *(sp + 3) = (png_byte)(png_ptr->background.green
++ & 0xff);
++ *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
++ & 0xff);
+ *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+ }
+
+@@ -4061,23 +3858,26 @@
+
+ v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+ png_composite_16(w, v, a, png_ptr->background_1.red);
+- if (!optimize)
+- w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
++ if (optimize == 0)
++ w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >>
++ 8];
+ *sp = (png_byte)((w >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(w & 0xff);
+
+ v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
+ png_composite_16(w, v, a, png_ptr->background_1.green);
+- if (!optimize)
+- w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
++ if (optimize == 0)
++ w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >>
++ 8];
+
+ *(sp + 2) = (png_byte)((w >> 8) & 0xff);
+ *(sp + 3) = (png_byte)(w & 0xff);
+
+ v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
+ png_composite_16(w, v, a, png_ptr->background_1.blue);
+- if (!optimize)
+- w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
++ if (optimize == 0)
++ w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >>
++ 8];
+
+ *(sp + 4) = (png_byte)((w >> 8) & 0xff);
+ *(sp + 5) = (png_byte)(w & 0xff);
+@@ -4098,9 +3898,12 @@
+ {
+ *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+ *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+- *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff);
+- *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff);
+- *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff);
++ *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
++ & 0xff);
++ *(sp + 3) = (png_byte)(png_ptr->background.green
++ & 0xff);
++ *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
++ & 0xff);
+ *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+ }
+
+@@ -4137,7 +3940,7 @@
+ }
+ }
+ }
+-#endif
++#endif /* READ_BACKGROUND || READ_ALPHA_MODE */
+
+ #ifdef PNG_READ_GAMMA_SUPPORTED
+ /* Gamma correct the image, avoiding the alpha channel. Make sure
+@@ -4146,8 +3949,8 @@
+ * is 16, use gamma_16_table and gamma_shift. Build these with
+ * build_gamma_table().
+ */
+-void /* PRIVATE */
+-png_do_gamma(png_row_infop row_info, png_bytep row, png_structp png_ptr)
++static void
++png_do_gamma(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
+ {
+ png_const_bytep gamma_table = png_ptr->gamma_table;
+ png_const_uint_16pp gamma_16_table = png_ptr->gamma_16_table;
+@@ -4347,14 +4150,14 @@
+ * linear.) Called only with color types that have an alpha channel. Needs the
+ * from_1 tables.
+ */
+-void /* PRIVATE */
+-png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structp png_ptr)
++static void
++png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
+ {
+ png_uint_32 row_width = row_info->width;
+
+ png_debug(1, "in png_do_encode_alpha");
+
+- if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
++ if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
+ {
+ if (row_info->bit_depth == 8)
+ {
+@@ -4413,7 +4216,7 @@
+ /* Expands a palette row to an RGB or RGBA row depending
+ * upon whether you supply trans and num_trans.
+ */
+-void /* PRIVATE */
++static void
+ png_do_expand_palette(png_row_infop row_info, png_bytep row,
+ png_const_colorp palette, png_const_bytep trans_alpha, int num_trans)
+ {
+@@ -4566,7 +4369,7 @@
+ /* If the bit depth < 8, it is expanded to 8. Also, if the already
+ * expanded transparency value is supplied, an alpha channel is built.
+ */
+-void /* PRIVATE */
++static void
+ png_do_expand(png_row_infop row_info, png_bytep row,
+ png_const_color_16p trans_color)
+ {
+@@ -4580,7 +4383,7 @@
+ {
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+- png_uint_16 gray = (png_uint_16)(trans_color ? trans_color->gray : 0);
++ unsigned int gray = trans_color != NULL ? trans_color->gray : 0;
+
+ if (row_info->bit_depth < 8)
+ {
+@@ -4588,7 +4391,7 @@
+ {
+ case 1:
+ {
+- gray = (png_uint_16)((gray & 0x01) * 0xff);
++ gray = (gray & 0x01) * 0xff;
+ sp = row + (png_size_t)((row_width - 1) >> 3);
+ dp = row + (png_size_t)row_width - 1;
+ shift = 7 - (int)((row_width + 7) & 0x07);
+@@ -4616,7 +4419,7 @@
+
+ case 2:
+ {
+- gray = (png_uint_16)((gray & 0x03) * 0x55);
++ gray = (gray & 0x03) * 0x55;
+ sp = row + (png_size_t)((row_width - 1) >> 2);
+ dp = row + (png_size_t)row_width - 1;
+ shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+@@ -4641,7 +4444,7 @@
+
+ case 4:
+ {
+- gray = (png_uint_16)((gray & 0x0f) * 0x11);
++ gray = (gray & 0x0f) * 0x11;
+ sp = row + (png_size_t)((row_width - 1) >> 1);
+ dp = row + (png_size_t)row_width - 1;
+ shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
+@@ -4694,8 +4497,8 @@
+
+ else if (row_info->bit_depth == 16)
+ {
+- png_byte gray_high = (png_byte)((gray >> 8) & 0xff);
+- png_byte gray_low = (png_byte)(gray & 0xff);
++ unsigned int gray_high = (gray >> 8) & 0xff;
++ unsigned int gray_low = gray & 0xff;
+ sp = row + row_info->rowbytes - 1;
+ dp = row + (row_info->rowbytes << 1) - 1;
+ for (i = 0; i < row_width; i++)
+@@ -4724,7 +4527,8 @@
+ row_width);
+ }
+ }
+- else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_color)
++ else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
++ trans_color != NULL)
+ {
+ if (row_info->bit_depth == 8)
+ {
+@@ -4793,10 +4597,10 @@
+ #endif
+
+ #ifdef PNG_READ_EXPAND_16_SUPPORTED
+-/* If the bit depth is 8 and the colour type is not a palette type expand the
++/* If the bit depth is 8 and the color type is not a palette type expand the
+ * whole row to 16 bits. Has no effect otherwise.
+ */
+-void /* PRIVATE */
++static void
+ png_do_expand_16(png_row_infop row_info, png_bytep row)
+ {
+ if (row_info->bit_depth == 8 &&
+@@ -4824,7 +4628,7 @@
+ #endif
+
+ #ifdef PNG_READ_QUANTIZE_SUPPORTED
+-void /* PRIVATE */
++static void
+ png_do_quantize(png_row_infop row_info, png_bytep row,
+ png_const_bytep palette_lookup, png_const_bytep quantize_lookup)
+ {
+@@ -4915,70 +4719,304 @@
+ }
+ }
+ }
+-#endif /* PNG_READ_QUANTIZE_SUPPORTED */
+-#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+-
+-#ifdef PNG_MNG_FEATURES_SUPPORTED
+-/* Undoes intrapixel differencing */
++#endif /* READ_QUANTIZE */
++
++/* Transform the row. The order of transformations is significant,
++ * and is very touchy. If you add a transformation, take care to
++ * decide how it fits in with the other transformations here.
++ */
+ void /* PRIVATE */
+-png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
++png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
+ {
+- png_debug(1, "in png_do_read_intrapixel");
+-
+- if (
+- (row_info->color_type & PNG_COLOR_MASK_COLOR))
++ png_debug(1, "in png_do_read_transformations");
++
++ if (png_ptr->row_buf == NULL)
+ {
+- int bytes_per_pixel;
+- png_uint_32 row_width = row_info->width;
+-
+- if (row_info->bit_depth == 8)
++ /* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this
++ * error is incredibly rare and incredibly easy to debug without this
++ * information.
++ */
++ png_error(png_ptr, "NULL row buffer");
++ }
++
++ /* The following is debugging; prior to 1.5.4 the code was never compiled in;
++ * in 1.5.4 PNG_FLAG_DETECT_UNINITIALIZED was added and the macro
++ * PNG_WARN_UNINITIALIZED_ROW removed. In 1.6 the new flag is set only for
++ * all transformations, however in practice the ROW_INIT always gets done on
++ * demand, if necessary.
++ */
++ if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 &&
++ (png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
++ {
++ /* Application has failed to call either png_read_start_image() or
++ * png_read_update_info() after setting transforms that expand pixels.
++ * This check added to libpng-1.2.19 (but not enabled until 1.5.4).
++ */
++ png_error(png_ptr, "Uninitialized row");
++ }
++
++#ifdef PNG_READ_EXPAND_SUPPORTED
++ if ((png_ptr->transformations & PNG_EXPAND) != 0)
++ {
++ if (row_info->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+- png_bytep rp;
+- png_uint_32 i;
+-
+- if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+- bytes_per_pixel = 3;
+-
+- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+- bytes_per_pixel = 4;
++ png_do_expand_palette(row_info, png_ptr->row_buf + 1,
++ png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
++ }
++
++ else
++ {
++ if (png_ptr->num_trans != 0 &&
++ (png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
++ png_do_expand(row_info, png_ptr->row_buf + 1,
++ &(png_ptr->trans_color));
+
+ else
+- return;
+-
+- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+- {
+- *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff);
+- *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff);
+- }
+- }
+- else if (row_info->bit_depth == 16)
+- {
+- png_bytep rp;
+- png_uint_32 i;
+-
+- if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+- bytes_per_pixel = 6;
+-
+- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+- bytes_per_pixel = 8;
+-
+- else
+- return;
+-
+- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+- {
+- png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1);
+- png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);
+- png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);
+- png_uint_32 red = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);
+- png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);
+- *(rp ) = (png_byte)((red >> 8) & 0xff);
+- *(rp + 1) = (png_byte)(red & 0xff);
+- *(rp + 4) = (png_byte)((blue >> 8) & 0xff);
+- *(rp + 5) = (png_byte)(blue & 0xff);
+- }
++ png_do_expand(row_info, png_ptr->row_buf + 1,
++ NULL);
+ }
+ }
++#endif
++
++#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
++ if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
++ (png_ptr->transformations & PNG_COMPOSE) == 0 &&
++ (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
++ png_do_strip_channel(row_info, png_ptr->row_buf + 1,
++ 0 /* at_start == false, because SWAP_ALPHA happens later */);
++#endif
++
++#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
++ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
++ {
++ int rgb_error =
++ png_do_rgb_to_gray(png_ptr, row_info,
++ png_ptr->row_buf + 1);
++
++ if (rgb_error != 0)
++ {
++ png_ptr->rgb_to_gray_status=1;
++ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
++ PNG_RGB_TO_GRAY_WARN)
++ png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
++
++ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
++ PNG_RGB_TO_GRAY_ERR)
++ png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
++ }
++ }
++#endif
++
++/* From Andreas Dilger e-mail to png-implement, 26 March 1998:
++ *
++ * In most cases, the "simple transparency" should be done prior to doing
++ * gray-to-RGB, or you will have to test 3x as many bytes to check if a
++ * pixel is transparent. You would also need to make sure that the
++ * transparency information is upgraded to RGB.
++ *
++ * To summarize, the current flow is:
++ * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
++ * with background "in place" if transparent,
++ * convert to RGB if necessary
++ * - Gray + alpha -> composite with gray background and remove alpha bytes,
++ * convert to RGB if necessary
++ *
++ * To support RGB backgrounds for gray images we need:
++ * - Gray + simple transparency -> convert to RGB + simple transparency,
++ * compare 3 or 6 bytes and composite with
++ * background "in place" if transparent
++ * (3x compare/pixel compared to doing
++ * composite with gray bkgrnd)
++ * - Gray + alpha -> convert to RGB + alpha, composite with background and
++ * remove alpha bytes (3x float
++ * operations/pixel compared with composite
++ * on gray background)
++ *
++ * Greg's change will do this. The reason it wasn't done before is for
++ * performance, as this increases the per-pixel operations. If we would check
++ * in advance if the background was gray or RGB, and position the gray-to-RGB
++ * transform appropriately, then it would save a lot of work/time.
++ */
++
++#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
++ /* If gray -> RGB, do so now only if background is non-gray; else do later
++ * for performance reasons
++ */
++ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
++ (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) == 0)
++ png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
++#endif
++
++#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
++ defined(PNG_READ_ALPHA_MODE_SUPPORTED)
++ if ((png_ptr->transformations & PNG_COMPOSE) != 0)
++ png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr);
++#endif
++
++#ifdef PNG_READ_GAMMA_SUPPORTED
++ if ((png_ptr->transformations & PNG_GAMMA) != 0 &&
++#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
++ /* Because RGB_TO_GRAY does the gamma transform. */
++ (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0 &&
++#endif
++#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
++ defined(PNG_READ_ALPHA_MODE_SUPPORTED)
++ /* Because PNG_COMPOSE does the gamma transform if there is something to
++ * do (if there is an alpha channel or transparency.)
++ */
++ !((png_ptr->transformations & PNG_COMPOSE) &&
++ ((png_ptr->num_trans != 0) ||
++ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)) &&
++#endif
++ /* Because png_init_read_transformations transforms the palette, unless
++ * RGB_TO_GRAY will do the transform.
++ */
++ (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
++ png_do_gamma(row_info, png_ptr->row_buf + 1, png_ptr);
++#endif
++
++#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
++ if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
++ (png_ptr->transformations & PNG_COMPOSE) != 0 &&
++ (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
++ png_do_strip_channel(row_info, png_ptr->row_buf + 1,
++ 0 /* at_start == false, because SWAP_ALPHA happens later */);
++#endif
++
++#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
++ if ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
++ (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
++ png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr);
++#endif
++
++#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
++ if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
++ png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
++ /* There is no harm in doing both of these because only one has any effect,
++ * by putting the 'scale' option first if the app asks for scale (either by
++ * calling the API or in a TRANSFORM flag) this is what happens.
++ */
++ if ((png_ptr->transformations & PNG_16_TO_8) != 0)
++ png_do_chop(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_QUANTIZE_SUPPORTED
++ if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
++ {
++ png_do_quantize(row_info, png_ptr->row_buf + 1,
++ png_ptr->palette_lookup, png_ptr->quantize_index);
++
++ if (row_info->rowbytes == 0)
++ png_error(png_ptr, "png_do_quantize returned rowbytes=0");
++ }
++#endif /* READ_QUANTIZE */
++
++#ifdef PNG_READ_EXPAND_16_SUPPORTED
++ /* Do the expansion now, after all the arithmetic has been done. Notice
++ * that previous transformations can handle the PNG_EXPAND_16 flag if this
++ * is efficient (particularly true in the case of gamma correction, where
++ * better accuracy results faster!)
++ */
++ if ((png_ptr->transformations & PNG_EXPAND_16) != 0)
++ png_do_expand_16(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
++ /* NOTE: moved here in 1.5.4 (from much later in this list.) */
++ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
++ (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) != 0)
++ png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_INVERT_SUPPORTED
++ if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
++ png_do_invert(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
++ if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
++ png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_SHIFT_SUPPORTED
++ if ((png_ptr->transformations & PNG_SHIFT) != 0)
++ png_do_unshift(row_info, png_ptr->row_buf + 1,
++ &(png_ptr->shift));
++#endif
++
++#ifdef PNG_READ_PACK_SUPPORTED
++ if ((png_ptr->transformations & PNG_PACK) != 0)
++ png_do_unpack(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
++ /* Added at libpng-1.5.10 */
++ if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
++ png_ptr->num_palette_max >= 0)
++ png_do_check_palette_indexes(png_ptr, row_info);
++#endif
++
++#ifdef PNG_READ_BGR_SUPPORTED
++ if ((png_ptr->transformations & PNG_BGR) != 0)
++ png_do_bgr(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_PACKSWAP_SUPPORTED
++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
++ png_do_packswap(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_FILLER_SUPPORTED
++ if ((png_ptr->transformations & PNG_FILLER) != 0)
++ png_do_read_filler(row_info, png_ptr->row_buf + 1,
++ (png_uint_32)png_ptr->filler, png_ptr->flags);
++#endif
++
++#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
++ if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
++ png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_READ_16BIT_SUPPORTED
++#ifdef PNG_READ_SWAP_SUPPORTED
++ if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
++ png_do_swap(row_info, png_ptr->row_buf + 1);
++#endif
++#endif
++
++#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
++ if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
++ {
++ if (png_ptr->read_user_transform_fn != NULL)
++ (*(png_ptr->read_user_transform_fn)) /* User read transform function */
++ (png_ptr, /* png_ptr */
++ row_info, /* row_info: */
++ /* png_uint_32 width; width of row */
++ /* png_size_t rowbytes; number of bytes in row */
++ /* png_byte color_type; color type of pixels */
++ /* png_byte bit_depth; bit depth of samples */
++ /* png_byte channels; number of channels (1-4) */
++ /* png_byte pixel_depth; bits per pixel (depth*channels) */
++ png_ptr->row_buf + 1); /* start of pixel data for row */
++#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
++ if (png_ptr->user_transform_depth != 0)
++ row_info->bit_depth = png_ptr->user_transform_depth;
++
++ if (png_ptr->user_transform_channels != 0)
++ row_info->channels = png_ptr->user_transform_channels;
++#endif
++ row_info->pixel_depth = (png_byte)(row_info->bit_depth *
++ row_info->channels);
++
++ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->width);
++ }
++#endif
+ }
+-#endif /* PNG_MNG_FEATURES_SUPPORTED */
+-#endif /* PNG_READ_SUPPORTED */
++
++#endif /* READ_TRANSFORMS */
++#endif /* READ */
+--- ./jdk/src/share/native/sun/awt/libpng/pngrutil.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngrutil.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -46,10 +46,8 @@
+
+ #ifdef PNG_READ_SUPPORTED
+
+-#define png_strtod(p,a,b) strtod(a,b)
+-
+ png_uint_32 PNGAPI
+-png_get_uint_31(png_structp png_ptr, png_const_bytep buf)
++png_get_uint_31(png_const_structrp png_ptr, png_const_bytep buf)
+ {
+ png_uint_32 uval = png_get_uint_32(buf);
+
+@@ -68,7 +66,7 @@
+ #define PNG_FIXED_ERROR (-1)
+
+ static png_fixed_point /* PRIVATE */
+-png_get_fixed_point(png_structp png_ptr, png_const_bytep buf)
++png_get_fixed_point(png_structrp png_ptr, png_const_bytep buf)
+ {
+ png_uint_32 uval = png_get_uint_32(buf);
+
+@@ -115,10 +113,10 @@
+ png_get_int_32)(png_const_bytep buf)
+ {
+ png_uint_32 uval = png_get_uint_32(buf);
+- if ((uval & 0x80000000L) == 0) /* non-negative */
++ if ((uval & 0x80000000) == 0) /* non-negative */
+ return uval;
+
+- uval = (uval ^ 0xffffffffL) + 1; /* 2's complement: -x = ~x+1 */
++ uval = (uval ^ 0xffffffff) + 1; /* 2's complement: -x = ~x+1 */
+ return -(png_int_32)uval;
+ }
+
+@@ -126,7 +124,7 @@
+ png_uint_16 (PNGAPI
+ png_get_uint_16)(png_const_bytep buf)
+ {
+- /* ANSI-C requires an int value to accommodate at least 16 bits so this
++ /* ANSI-C requires an int value to accomodate at least 16 bits so this
+ * works and allows the compiler not to worry about possible narrowing
+ * on 32 bit systems. (Pre-ANSI systems did not make integers smaller
+ * than 16 bits either.)
+@@ -138,11 +136,11 @@
+ return (png_uint_16)val;
+ }
+
+-#endif /* PNG_READ_INT_FUNCTIONS_SUPPORTED */
++#endif /* READ_INT_FUNCTIONS */
+
+ /* Read and check the PNG file signature */
+ void /* PRIVATE */
+-png_read_sig(png_structp png_ptr, png_infop info_ptr)
++png_read_sig(png_structrp png_ptr, png_inforp info_ptr)
+ {
+ png_size_t num_checked, num_to_check;
+
+@@ -161,7 +159,7 @@
+ png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
+ png_ptr->sig_bytes = 8;
+
+- if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
++ if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check) != 0)
+ {
+ if (num_checked < 4 &&
+ png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
+@@ -177,7 +175,7 @@
+ * Put the type name into png_ptr->chunk_name, and return the length.
+ */
+ png_uint_32 /* PRIVATE */
+-png_read_chunk_header(png_structp png_ptr)
++png_read_chunk_header(png_structrp png_ptr)
+ {
+ png_byte buf[8];
+ png_uint_32 length;
+@@ -193,14 +191,14 @@
+ length = png_get_uint_31(png_ptr, buf);
+
+ /* Put the chunk name into png_ptr->chunk_name. */
+- png_memcpy(png_ptr->chunk_name, buf + 4, 4);
+-
+- png_debug2(0, "Reading %s chunk, length = %u",
+- png_ptr->chunk_name, length);
++ png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4);
++
++ png_debug2(0, "Reading %lx chunk, length = %lu",
++ (unsigned long)png_ptr->chunk_name, (unsigned long)length);
+
+ /* Reset the crc and run it over the chunk name. */
+ png_reset_crc(png_ptr);
+- png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
++ png_calculate_crc(png_ptr, buf + 4, 4);
+
+ /* Check to see if chunk name is valid. */
+ png_check_chunk_name(png_ptr, png_ptr->chunk_name);
+@@ -214,7 +212,7 @@
+
+ /* Read data, and (optionally) run it through the CRC. */
+ void /* PRIVATE */
+-png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
++png_crc_read(png_structrp png_ptr, png_bytep buf, png_uint_32 length)
+ {
+ if (png_ptr == NULL)
+ return;
+@@ -224,41 +222,40 @@
+ }
+
+ /* 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.
+ */
+ int /* PRIVATE */
+-png_crc_finish(png_structp png_ptr, png_uint_32 skip)
++png_crc_finish(png_structrp png_ptr, png_uint_32 skip)
+ {
+- png_size_t i;
+- png_size_t istop = png_ptr->zbuf_size;
+-
+- for (i = (png_size_t)skip; i > istop; i -= istop)
++ /* The size of the local buffer for inflate is a good guess as to a
++ * reasonable size to use for buffering reads from the application.
++ */
++ while (skip > 0)
+ {
+- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
++ png_uint_32 len;
++ png_byte tmpbuf[PNG_INFLATE_BUF_SIZE];
++
++ len = (sizeof tmpbuf);
++ if (len > skip)
++ len = skip;
++ skip -= len;
++
++ png_crc_read(png_ptr, tmpbuf, len);
+ }
+
+- if (i)
++ if (png_crc_error(png_ptr) != 0)
+ {
+- png_crc_read(png_ptr, png_ptr->zbuf, i);
+- }
+-
+- if (png_crc_error(png_ptr))
+- {
+- if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
+- !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
+- (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
+- (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
++ if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0 ?
++ (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) == 0 :
++ (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE) != 0)
+ {
+ png_chunk_warning(png_ptr, "CRC error");
+ }
+
+ else
+- {
+- png_chunk_benign_error(png_ptr, "CRC error");
+- return (0);
+- }
++ png_chunk_error(png_ptr, "CRC error");
+
+ return (1);
+ }
+@@ -270,22 +267,22 @@
+ * the data it has read thus far.
+ */
+ int /* PRIVATE */
+-png_crc_error(png_structp png_ptr)
++png_crc_error(png_structrp png_ptr)
+ {
+ png_byte crc_bytes[4];
+ png_uint_32 crc;
+ int need_crc = 1;
+
+- if (png_ptr->chunk_name[0] & 0x20) /* ancillary */
++ if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
+ {
+ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
+ (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
+ need_crc = 0;
+ }
+
+- else /* critical */
++ else /* critical */
+ {
+- if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
++ if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
+ need_crc = 0;
+ }
+
+@@ -296,7 +293,7 @@
+ /* The chunk CRC must be serialized in a single I/O call. */
+ png_read_data(png_ptr, crc_bytes, 4);
+
+- if (need_crc)
++ if (need_crc != 0)
+ {
+ crc = png_get_uint_32(crc_bytes);
+ return ((int)(crc != png_ptr->crc));
+@@ -306,252 +303,522 @@
+ return (0);
+ }
+
++#if defined(PNG_READ_iCCP_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) ||\
++ defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_READ_sCAL_SUPPORTED) ||\
++ defined(PNG_READ_sPLT_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) ||\
++ defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_SEQUENTIAL_READ_SUPPORTED)
++/* 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
++ * it will call png_error (via png_malloc) on failure. (warn == 2 means
++ * 'silent').
++ */
++static png_bytep
++png_read_buffer(png_structrp png_ptr, png_alloc_size_t new_size, int warn)
++{
++ png_bytep buffer = png_ptr->read_buffer;
++
++ if (buffer != NULL && new_size > png_ptr->read_buffer_size)
++ {
++ png_ptr->read_buffer = NULL;
++ png_ptr->read_buffer = NULL;
++ png_ptr->read_buffer_size = 0;
++ png_free(png_ptr, buffer);
++ buffer = NULL;
++ }
++
++ if (buffer == NULL)
++ {
++ buffer = png_voidcast(png_bytep, png_malloc_base(png_ptr, new_size));
++
++ if (buffer != NULL)
++ {
++ png_ptr->read_buffer = buffer;
++ png_ptr->read_buffer_size = new_size;
++ }
++
++ else if (warn < 2) /* else silent */
++ {
++ if (warn != 0)
++ png_chunk_warning(png_ptr, "insufficient memory to read chunk");
++
++ else
++ png_chunk_error(png_ptr, "insufficient memory to read chunk");
++ }
++ }
++
++ return buffer;
++}
++#endif /* READ_iCCP|iTXt|pCAL|sCAL|sPLT|tEXt|zTXt|SEQUENTIAL_READ */
++
++/* png_inflate_claim: claim the zstream for some nefarious purpose that involves
++ * decompression. Returns Z_OK on success, else a zlib error code. It checks
++ * the owner but, in final release builds, just issues a warning if some other
++ * chunk apparently owns the stream. Prior to release it does a png_error.
++ */
++static int
++png_inflate_claim(png_structrp png_ptr, png_uint_32 owner)
++{
++ if (png_ptr->zowner != 0)
++ {
++ char msg[64];
++
++ PNG_STRING_FROM_CHUNK(msg, png_ptr->zowner);
++ /* So the message that results is "<chunk> using zstream"; this is an
++ * internal error, but is very useful for debugging. i18n requirements
++ * are minimal.
++ */
++ (void)png_safecat(msg, (sizeof msg), 4, " using zstream");
++#if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
++ png_chunk_warning(png_ptr, msg);
++ png_ptr->zowner = 0;
++#else
++ png_chunk_error(png_ptr, msg);
++#endif
++ }
++
++ /* 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 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
++ * size with earlier zlibs just in case later compressed chunks need it.
++ */
++ {
++ int ret; /* zlib return code */
++#if PNG_ZLIB_VERNUM >= 0x1240
++
++# if defined(PNG_SET_OPTION_SUPPORTED) && defined(PNG_MAXIMUM_INFLATE_WINDOW)
++ int window_bits;
++
++ if (((png_ptr->options >> PNG_MAXIMUM_INFLATE_WINDOW) & 3) ==
++ PNG_OPTION_ON)
++ window_bits = 15;
++
++ else
++ window_bits = 0;
++# else
++# define window_bits 0
++# endif
++#endif
++
++ /* Set this for safety, just in case the previous owner left pointers to
++ * memory allocations.
++ */
++ png_ptr->zstream.next_in = NULL;
++ png_ptr->zstream.avail_in = 0;
++ png_ptr->zstream.next_out = NULL;
++ png_ptr->zstream.avail_out = 0;
++
++ if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
++ {
++#if PNG_ZLIB_VERNUM < 0x1240
++ ret = inflateReset(&png_ptr->zstream);
++#else
++ ret = inflateReset2(&png_ptr->zstream, window_bits);
++#endif
++ }
++
++ else
++ {
++#if PNG_ZLIB_VERNUM < 0x1240
++ ret = inflateInit(&png_ptr->zstream);
++#else
++ ret = inflateInit2(&png_ptr->zstream, window_bits);
++#endif
++
++ if (ret == Z_OK)
++ png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
++ }
++
++ if (ret == Z_OK)
++ png_ptr->zowner = owner;
++
++ else
++ png_zstream_error(png_ptr, ret);
++
++ return ret;
++ }
++
++#ifdef window_bits
++# undef window_bits
++#endif
++}
++
+ #ifdef PNG_READ_COMPRESSED_TEXT_SUPPORTED
+-static png_size_t
+-png_inflate(png_structp png_ptr, png_bytep data, png_size_t size,
+- png_bytep output, png_size_t output_size)
++/* png_inflate now returns zlib error codes including Z_OK and Z_STREAM_END to
++ * allow the caller to do multiple calls if required. If the 'finish' flag is
++ * set Z_FINISH will be passed to the final inflate() call and Z_STREAM_END must
++ * be returned or there has been a problem, otherwise Z_SYNC_FLUSH is used and
++ * Z_OK or Z_STREAM_END will be returned on success.
++ *
++ * The input and output sizes are updated to the actual amounts of data consumed
++ * or written, not the amount available (as in a z_stream). The data pointers
++ * are not changed, so the next input is (data+input_size) and the next
++ * available output is (output+output_size).
++ */
++static int
++png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish,
++ /* INPUT: */ png_const_bytep input, png_uint_32p input_size_ptr,
++ /* OUTPUT: */ png_bytep output, png_alloc_size_t *output_size_ptr)
+ {
+- png_size_t count = 0;
+-
+- /* zlib can't necessarily handle more than 65535 bytes at once (i.e. it can't
+- * even necessarily handle 65536 bytes) because the type uInt is "16 bits or
+- * more". Consequently it is necessary to chunk the input to zlib. This
+- * code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the maximum value
+- * that can be stored in a uInt.) It is possible to set ZLIB_IO_MAX to a
+- * lower value in pngpriv.h and this may sometimes have a performance
+- * advantage, because it forces access of the input data to be separated from
+- * at least some of the use by some period of time.
+- */
+- png_ptr->zstream.next_in = data;
+- /* avail_in is set below from 'size' */
+- png_ptr->zstream.avail_in = 0;
+-
+- while (1)
++ if (png_ptr->zowner == owner) /* Else not claimed */
+ {
+- int ret, avail;
+-
+- /* The setting of 'avail_in' used to be outside the loop, by setting it
+- * inside it is possible to chunk the input to zlib and simply rely on
+- * zlib to advance the 'next_in' pointer. This allows arbitrary amounts o
+- * data to be passed through zlib at the unavoidable cost of requiring a
+- * window save (memcpy of up to 32768 output bytes) every ZLIB_IO_MAX
+- * input bytes.
++ int ret;
++ png_alloc_size_t avail_out = *output_size_ptr;
++ png_uint_32 avail_in = *input_size_ptr;
++
++ /* zlib can't necessarily handle more than 65535 bytes at once (i.e. it
++ * can't even necessarily handle 65536 bytes) because the type uInt is
++ * "16 bits or more". Consequently it is necessary to chunk the input to
++ * zlib. This code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the
++ * maximum value that can be stored in a uInt.) It is possible to set
++ * ZLIB_IO_MAX to a lower value in pngpriv.h and this may sometimes have
++ * a performance advantage, because it reduces the amount of data accessed
++ * at each step and that may give the OS more time to page it in.
+ */
+- if (png_ptr->zstream.avail_in == 0 && size > 0)
++ png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
++ /* avail_in and avail_out are set below from 'size' */
++ png_ptr->zstream.avail_in = 0;
++ png_ptr->zstream.avail_out = 0;
++
++ /* Read directly into the output if it is available (this is set to
++ * a local buffer below if output is NULL).
++ */
++ if (output != NULL)
++ png_ptr->zstream.next_out = output;
++
++ do
+ {
+- if (size <= ZLIB_IO_MAX)
++ uInt avail;
++ Byte local_buffer[PNG_INFLATE_BUF_SIZE];
++
++ /* zlib INPUT BUFFER */
++ /* The setting of 'avail_in' used to be outside the loop; by setting it
++ * inside it is possible to chunk the input to zlib and simply rely on
++ * zlib to advance the 'next_in' pointer. This allows arbitrary
++ * amounts of data to be passed through zlib at the unavoidable cost of
++ * requiring a window save (memcpy of up to 32768 output bytes)
++ * every ZLIB_IO_MAX input bytes.
++ */
++ avail_in += png_ptr->zstream.avail_in; /* not consumed last time */
++
++ avail = ZLIB_IO_MAX;
++
++ if (avail_in < avail)
++ avail = (uInt)avail_in; /* safe: < than ZLIB_IO_MAX */
++
++ avail_in -= avail;
++ png_ptr->zstream.avail_in = avail;
++
++ /* zlib OUTPUT BUFFER */
++ avail_out += png_ptr->zstream.avail_out; /* not written last time */
++
++ avail = ZLIB_IO_MAX; /* maximum zlib can process */
++
++ if (output == NULL)
+ {
+- /* The value is less than ZLIB_IO_MAX so the cast is safe: */
+- png_ptr->zstream.avail_in = (uInt)size;
+- size = 0;
++ /* Reset the output buffer each time round if output is NULL and
++ * make available the full buffer, up to 'remaining_space'
++ */
++ png_ptr->zstream.next_out = local_buffer;
++ if ((sizeof local_buffer) < avail)
++ avail = (sizeof local_buffer);
+ }
+
+- else
+- {
+- png_ptr->zstream.avail_in = ZLIB_IO_MAX;
+- size -= ZLIB_IO_MAX;
+- }
+- }
+-
+- /* Reset the output buffer each time round - we empty it
+- * after every inflate call.
++ if (avail_out < avail)
++ avail = (uInt)avail_out; /* safe: < ZLIB_IO_MAX */
++
++ png_ptr->zstream.avail_out = avail;
++ avail_out -= avail;
++
++ /* zlib inflate call */
++ /* In fact 'avail_out' may be 0 at this point, that happens at the end
++ * of the read when the final LZ end code was not passed at the end of
++ * the previous chunk of input data. Tell zlib if we have reached the
++ * end of the output buffer.
++ */
++ ret = inflate(&png_ptr->zstream, avail_out > 0 ? Z_NO_FLUSH :
++ (finish ? Z_FINISH : Z_SYNC_FLUSH));
++ } while (ret == Z_OK);
++
++ /* For safety kill the local buffer pointer now */
++ if (output == NULL)
++ png_ptr->zstream.next_out = NULL;
++
++ /* Claw back the 'size' and 'remaining_space' byte counts. */
++ avail_in += png_ptr->zstream.avail_in;
++ avail_out += png_ptr->zstream.avail_out;
++
++ /* Update the input and output sizes; the updated values are the amount
++ * consumed or written, effectively the inverse of what zlib uses.
+ */
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- png_ptr->zstream.avail_out = png_ptr->zbuf_size;
+-
+- ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
+- avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out;
+-
+- /* First copy/count any new output - but only if we didn't
+- * get an error code.
++ if (avail_out > 0)
++ *output_size_ptr -= avail_out;
++
++ if (avail_in > 0)
++ *input_size_ptr -= avail_in;
++
++ /* Ensure png_ptr->zstream.msg is set (even in the success case!) */
++ png_zstream_error(png_ptr, ret);
++ return ret;
++ }
++
++ else
++ {
++ /* This is a bad internal error. The recovery assigns to the zstream msg
++ * pointer, which is not owned by the caller, but this is safe; it's only
++ * used on errors!
+ */
+- if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0)
+- {
+- png_size_t space = avail; /* > 0, see above */
+-
+- if (output != 0 && output_size > count)
+- {
+- png_size_t copy = output_size - count;
+-
+- if (space < copy)
+- copy = space;
+-
+- png_memcpy(output + count, png_ptr->zbuf, copy);
+- }
+- count += space;
+- }
+-
+- if (ret == Z_OK)
+- continue;
+-
+- /* Termination conditions - always reset the zstream, it
+- * must be left in inflateInit state.
+- */
+- png_ptr->zstream.avail_in = 0;
+- inflateReset(&png_ptr->zstream);
+-
+- if (ret == Z_STREAM_END)
+- return count; /* NOTE: may be zero. */
+-
+- /* Now handle the error codes - the API always returns 0
+- * and the error message is dumped into the uncompressed
+- * buffer if available.
+- */
+-# ifdef PNG_WARNINGS_SUPPORTED
+- {
+- png_const_charp msg;
+-
+- if (png_ptr->zstream.msg != 0)
+- msg = png_ptr->zstream.msg;
+-
+- else switch (ret)
+- {
+- case Z_BUF_ERROR:
+- msg = "Buffer error in compressed datastream";
+- break;
+-
+- case Z_DATA_ERROR:
+- msg = "Data error in compressed datastream";
+- break;
+-
+- default:
+- msg = "Incomplete compressed datastream";
+- break;
+- }
+-
+- png_chunk_warning(png_ptr, msg);
+- }
+-# endif
+-
+- /* 0 means an error - notice that this code simply ignores
+- * zero length compressed chunks as a result.
+- */
+- return 0;
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");
++ return Z_STREAM_ERROR;
+ }
+ }
+
+ /*
+- * Decompress trailing data in a chunk. The assumption is that chunkdata
++ * Decompress trailing data in a chunk. The assumption is that read_buffer
+ * points at an allocated area holding the contents of a chunk with a
+ * trailing compressed part. What we get back is an allocated area
+ * holding the original prefix part and an uncompressed version of the
+ * trailing part (the malloc area passed in is freed).
+ */
++static int
++png_decompress_chunk(png_structrp png_ptr,
++ png_uint_32 chunklength, png_uint_32 prefix_size,
++ png_alloc_size_t *newlength /* must be initialized to the maximum! */,
++ int terminate /*add a '\0' to the end of the uncompressed data*/)
++{
++ /* TODO: implement different limits for different types of chunk.
++ *
++ * The caller supplies *newlength set to the maximum length of the
++ * uncompressed data, but this routine allocates space for the prefix and
++ * maybe a '\0' terminator too. We have to assume that 'prefix_size' is
++ * limited only by the maximum chunk size.
++ */
++ png_alloc_size_t limit = PNG_SIZE_MAX;
++
++# ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED
++ if (png_ptr->user_chunk_malloc_max > 0 &&
++ png_ptr->user_chunk_malloc_max < limit)
++ limit = png_ptr->user_chunk_malloc_max;
++# elif PNG_USER_CHUNK_MALLOC_MAX > 0
++ if (PNG_USER_CHUNK_MALLOC_MAX < limit)
++ limit = PNG_USER_CHUNK_MALLOC_MAX;
++# endif
++
++ if (limit >= prefix_size + (terminate != 0))
++ {
++ int ret;
++
++ limit -= prefix_size + (terminate != 0);
++
++ if (limit < *newlength)
++ *newlength = limit;
++
++ /* Now try to claim the stream. */
++ ret = png_inflate_claim(png_ptr, png_ptr->chunk_name);
++
++ if (ret == Z_OK)
++ {
++ png_uint_32 lzsize = chunklength - prefix_size;
++
++ ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
++ /* input: */ png_ptr->read_buffer + prefix_size, &lzsize,
++ /* output: */ NULL, newlength);
++
++ if (ret == Z_STREAM_END)
++ {
++ /* Use 'inflateReset' here, not 'inflateReset2' because this
++ * preserves the previously decided window size (otherwise it would
++ * be necessary to store the previous window size.) In practice
++ * this doesn't matter anyway, because png_inflate will call inflate
++ * with Z_FINISH in almost all cases, so the window will not be
++ * maintained.
++ */
++ if (inflateReset(&png_ptr->zstream) == Z_OK)
++ {
++ /* Because of the limit checks above we know that the new,
++ * expanded, size will fit in a size_t (let alone an
++ * png_alloc_size_t). Use png_malloc_base here to avoid an
++ * extra OOM message.
++ */
++ png_alloc_size_t new_size = *newlength;
++ png_alloc_size_t buffer_size = prefix_size + new_size +
++ (terminate != 0);
++ png_bytep text = png_voidcast(png_bytep, png_malloc_base(png_ptr,
++ buffer_size));
++
++ if (text != NULL)
++ {
++ ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
++ png_ptr->read_buffer + prefix_size, &lzsize,
++ text + prefix_size, newlength);
++
++ if (ret == Z_STREAM_END)
++ {
++ if (new_size == *newlength)
++ {
++ if (terminate != 0)
++ text[prefix_size + *newlength] = 0;
++
++ if (prefix_size > 0)
++ memcpy(text, png_ptr->read_buffer, prefix_size);
++
++ {
++ png_bytep old_ptr = png_ptr->read_buffer;
++
++ png_ptr->read_buffer = text;
++ png_ptr->read_buffer_size = buffer_size;
++ text = old_ptr; /* freed below */
++ }
++ }
++
++ else
++ {
++ /* The size changed on the second read, there can be no
++ * guarantee that anything is correct at this point.
++ * The 'msg' pointer has been set to "unexpected end of
++ * LZ stream", which is fine, but return an error code
++ * that the caller won't accept.
++ */
++ ret = PNG_UNEXPECTED_ZLIB_RETURN;
++ }
++ }
++
++ else if (ret == Z_OK)
++ ret = PNG_UNEXPECTED_ZLIB_RETURN; /* for safety */
++
++ /* Free the text pointer (this is the old read_buffer on
++ * success)
++ */
++ png_free(png_ptr, text);
++ text = NULL;
++
++ /* This really is very benign, but it's still an error because
++ * the extra space may otherwise be used as a Trojan Horse.
++ */
++ if (ret == Z_STREAM_END &&
++ chunklength - prefix_size != lzsize)
++ png_chunk_benign_error(png_ptr, "extra compressed data");
++ }
++
++ else
++ {
++ /* Out of memory allocating the buffer */
++ ret = Z_MEM_ERROR;
++ png_zstream_error(png_ptr, Z_MEM_ERROR);
++ }
++ }
++
++ else
++ {
++ /* inflateReset failed, store the error message */
++ png_zstream_error(png_ptr, ret);
++
++ if (ret == Z_STREAM_END)
++ ret = PNG_UNEXPECTED_ZLIB_RETURN;
++ }
++ }
++
++ else if (ret == Z_OK)
++ ret = PNG_UNEXPECTED_ZLIB_RETURN;
++
++ /* Release the claimed stream */
++ png_ptr->zowner = 0;
++ }
++
++ else /* the claim failed */ if (ret == Z_STREAM_END) /* impossible! */
++ ret = PNG_UNEXPECTED_ZLIB_RETURN;
++
++ return ret;
++ }
++
++ else
++ {
++ /* Application/configuration limits exceeded */
++ png_zstream_error(png_ptr, Z_MEM_ERROR);
++ return Z_MEM_ERROR;
++ }
++}
++#endif /* READ_COMPRESSED_TEXT */
++
++#ifdef PNG_READ_iCCP_SUPPORTED
++/* Perform a partial read and decompress, producing 'avail_out' bytes and
++ * reading from the current chunk as required.
++ */
++static int
++png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size,
++ png_uint_32p chunk_bytes, png_bytep next_out, png_alloc_size_t *out_size,
++ int finish)
++{
++ if (png_ptr->zowner == png_ptr->chunk_name)
++ {
++ int ret;
++
++ /* next_in and avail_in must have been initialized by the caller. */
++ png_ptr->zstream.next_out = next_out;
++ png_ptr->zstream.avail_out = 0; /* set in the loop */
++
++ do
++ {
++ if (png_ptr->zstream.avail_in == 0)
++ {
++ if (read_size > *chunk_bytes)
++ read_size = (uInt)*chunk_bytes;
++ *chunk_bytes -= read_size;
++
++ if (read_size > 0)
++ png_crc_read(png_ptr, read_buffer, read_size);
++
++ png_ptr->zstream.next_in = read_buffer;
++ png_ptr->zstream.avail_in = read_size;
++ }
++
++ if (png_ptr->zstream.avail_out == 0)
++ {
++ uInt avail = ZLIB_IO_MAX;
++ if (avail > *out_size)
++ avail = (uInt)*out_size;
++ *out_size -= avail;
++
++ png_ptr->zstream.avail_out = avail;
++ }
++
++ /* Use Z_SYNC_FLUSH when there is no more chunk data to ensure that all
++ * the available output is produced; this allows reading of truncated
++ * streams.
++ */
++ ret = inflate(&png_ptr->zstream,
++ *chunk_bytes > 0 ? Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH));
++ }
++ while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0));
++
++ *out_size += png_ptr->zstream.avail_out;
++ png_ptr->zstream.avail_out = 0; /* Should not be required, but is safe */
++
++ /* Ensure the error message pointer is always set: */
++ png_zstream_error(png_ptr, ret);
++ return ret;
++ }
++
++ else
++ {
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");
++ return Z_STREAM_ERROR;
++ }
++}
++#endif
++
++/* Read and check the IDHR chunk */
++
+ void /* PRIVATE */
+-png_decompress_chunk(png_structp png_ptr, int comp_type,
+- png_size_t chunklength,
+- png_size_t prefix_size, png_size_t *newlength)
+-{
+- /* The caller should guarantee this */
+- if (prefix_size > chunklength)
+- {
+- /* The recovery is to delete the chunk. */
+- png_warning(png_ptr, "invalid chunklength");
+- prefix_size = 0; /* To delete everything */
+- }
+-
+- else if (comp_type == PNG_COMPRESSION_TYPE_BASE)
+- {
+- png_size_t expanded_size = png_inflate(png_ptr,
+- (png_bytep)(png_ptr->chunkdata + prefix_size),
+- chunklength - prefix_size,
+- 0, /* output */
+- 0); /* output size */
+-
+- /* Now check the limits on this chunk - if the limit fails the
+- * compressed data will be removed, the prefix will remain.
+- */
+-#ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED
+- if (png_ptr->user_chunk_malloc_max &&
+- (prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1))
+-#else
+-# ifdef PNG_USER_CHUNK_MALLOC_MAX
+- if ((PNG_USER_CHUNK_MALLOC_MAX > 0) &&
+- prefix_size + expanded_size >= PNG_USER_CHUNK_MALLOC_MAX - 1)
+-# endif
+-#endif
+- png_warning(png_ptr, "Exceeded size limit while expanding chunk");
+-
+- /* If the size is zero either there was an error and a message
+- * has already been output (warning) or the size really is zero
+- * and we have nothing to do - the code will exit through the
+- * error case below.
+- */
+-#if defined(PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED) || \
+- defined(PNG_USER_CHUNK_MALLOC_MAX)
+- else if (expanded_size > 0)
+-#else
+- if (expanded_size > 0)
+-#endif
+- {
+- /* Success (maybe) - really uncompress the chunk. */
+- png_size_t new_size = 0;
+- png_charp text = png_malloc_warn(png_ptr,
+- prefix_size + expanded_size + 1);
+-
+- if (text != NULL)
+- {
+- png_memcpy(text, png_ptr->chunkdata, prefix_size);
+- new_size = png_inflate(png_ptr,
+- (png_bytep)(png_ptr->chunkdata + prefix_size),
+- chunklength - prefix_size,
+- (png_bytep)(text + prefix_size), expanded_size);
+- text[prefix_size + expanded_size] = 0; /* just in case */
+-
+- if (new_size == expanded_size)
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = text;
+- *newlength = prefix_size + expanded_size;
+- return; /* The success return! */
+- }
+-
+- png_warning(png_ptr, "png_inflate logic error");
+- png_free(png_ptr, text);
+- }
+-
+- else
+- png_warning(png_ptr, "Not enough memory to decompress chunk");
+- }
+- }
+-
+- else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */
+- {
+- PNG_WARNING_PARAMETERS(p)
+- png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d, comp_type);
+- png_formatted_warning(png_ptr, p, "Unknown zTXt compression type @1");
+-
+- /* The recovery is to simply drop the data. */
+- }
+-
+- /* Generic error return - leave the prefix, delete the compressed
+- * data, reallocate the chunkdata to remove the potentially large
+- * amount of compressed data.
+- */
+- {
+- png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);
+-
+- if (text != NULL)
+- {
+- if (prefix_size > 0)
+- png_memcpy(text, png_ptr->chunkdata, prefix_size);
+-
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = text;
+-
+- /* This is an extra zero in the 'uncompressed' part. */
+- *(png_ptr->chunkdata + prefix_size) = 0x00;
+- }
+- /* Ignore a malloc error here - it is safe. */
+- }
+-
+- *newlength = prefix_size;
+-}
+-#endif /* PNG_READ_COMPRESSED_TEXT_SUPPORTED */
+-
+-/* Read and check the IDHR chunk */
+-void /* PRIVATE */
+-png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_byte buf[13];
+ png_uint_32 width, height;
+@@ -560,12 +827,12 @@
+
+ png_debug(1, "in png_handle_IHDR");
+
+- if (png_ptr->mode & PNG_HAVE_IHDR)
+- png_error(png_ptr, "Out of place IHDR");
++ if ((png_ptr->mode & PNG_HAVE_IHDR) != 0)
++ png_chunk_error(png_ptr, "out of place");
+
+ /* Check the length */
+ if (length != 13)
+- png_error(png_ptr, "Invalid IHDR chunk");
++ png_chunk_error(png_ptr, "invalid");
+
+ png_ptr->mode |= PNG_HAVE_IHDR;
+
+@@ -614,8 +881,7 @@
+ }
+
+ /* Set up other useful info */
+- png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
+- png_ptr->channels);
++ png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * png_ptr->channels);
+ png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
+ png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
+ png_debug1(3, "channels = %d", png_ptr->channels);
+@@ -626,7 +892,7 @@
+
+ /* Read and check the palette */
+ void /* PRIVATE */
+-png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_PLTE(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_color palette[PNG_MAX_PALETTE_LENGTH];
+ int num, i;
+@@ -636,26 +902,33 @@
+
+ png_debug(1, "in png_handle_PLTE");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before PLTE");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ /* Moved to before the 'after IDAT' check below because otherwise duplicate
++ * PLTE chunks are potentially ignored (the spec says there shall not be more
++ * than one PLTE, the error is not treated as benign, so this check trumps
++ * the requirement that PLTE appears before IDAT.)
++ */
++ else if ((png_ptr->mode & PNG_HAVE_PLTE) != 0)
++ png_chunk_error(png_ptr, "duplicate");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ {
+- png_warning(png_ptr, "Invalid PLTE after IDAT");
++ /* This is benign because the non-benign error happened before, when an
++ * IDAT was encountered in a color-mapped image with no PLTE.
++ */
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- else if (png_ptr->mode & PNG_HAVE_PLTE)
+- png_error(png_ptr, "Duplicate PLTE chunk");
+-
+ png_ptr->mode |= PNG_HAVE_PLTE;
+
+- if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
+ {
+- png_warning(png_ptr,
+- "Ignoring PLTE chunk in grayscale PNG");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "ignored in grayscale PNG");
+ return;
+ }
+
+@@ -669,19 +942,18 @@
+
+ if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)
+ {
++ png_crc_finish(png_ptr, length);
++
+ if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+- {
+- png_warning(png_ptr, "Invalid palette chunk");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
++ png_chunk_benign_error(png_ptr, "invalid");
+
+ else
+- {
+- png_error(png_ptr, "Invalid palette chunk");
+- }
++ png_chunk_error(png_ptr, "invalid");
++
++ return;
+ }
+
++ /* The cast is safe because 'length' is less than 3*PNG_MAX_PALETTE_LENGTH */
+ num = (int)length / 3;
+
+ #ifdef PNG_POINTER_INDEXING_SUPPORTED
+@@ -720,214 +992,196 @@
+ }
+
+ #ifndef PNG_READ_OPT_PLTE_SUPPORTED
+- else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */
++ else if (png_crc_error(png_ptr) != 0) /* Only if we have a CRC error */
+ {
+ /* If we don't want to use the data from an ancillary chunk,
+ * we have two options: an error abort, or a warning and we
+ * ignore the data in this chunk (which should be OK, since
+ * it's considered ancillary for a RGB or RGBA image).
++ *
++ * IMPLEMENTATION NOTE: this is only here because png_crc_finish uses the
++ * chunk type to determine whether to check the ancillary or the critical
++ * flags.
+ */
+- if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))
++ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE) == 0)
+ {
+- if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)
+- {
+- png_chunk_benign_error(png_ptr, "CRC error");
+- }
++ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) != 0)
++ return;
+
+ else
+- {
+- png_chunk_warning(png_ptr, "CRC error");
+- return;
+- }
++ png_chunk_error(png_ptr, "CRC error");
+ }
+
+ /* Otherwise, we (optionally) emit a warning and use the chunk. */
+- else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))
+- {
++ else if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) == 0)
+ png_chunk_warning(png_ptr, "CRC error");
+- }
+ }
+ #endif
+
++ /* TODO: png_set_PLTE has the side effect of setting png_ptr->palette to its
++ * own copy of the palette. This has the side effect that when png_start_row
++ * is called (this happens after any call to png_read_update_info) the
++ * info_ptr palette gets changed. This is extremely unexpected and
++ * confusing.
++ *
++ * Fix this by not sharing the palette in this way.
++ */
+ png_set_PLTE(png_ptr, info_ptr, palette, num);
+
++ /* The three chunks, bKGD, hIST and tRNS *must* appear after PLTE and before
++ * IDAT. Prior to 1.6.0 this was not checked; instead the code merely
++ * checked the apparent validity of a tRNS chunk inserted before PLTE on a
++ * palette PNG. 1.6.0 attempts to rigorously follow the standard and
++ * therefore does a benign error if the erroneous condition is detected *and*
++ * cancels the tRNS if the benign error returns. The alternative is to
++ * amend the standard since it would be rather hypocritical of the standards
++ * maintainers to ignore it.
++ */
+ #ifdef PNG_READ_tRNS_SUPPORTED
+- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
++ if (png_ptr->num_trans > 0 ||
++ (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS) != 0))
+ {
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
+- {
+- if (png_ptr->num_trans > (png_uint_16)num)
+- {
+- png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
+- png_ptr->num_trans = (png_uint_16)num;
+- }
+-
+- if (info_ptr->num_trans > (png_uint_16)num)
+- {
+- png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");
+- info_ptr->num_trans = (png_uint_16)num;
+- }
+- }
++ /* Cancel this because otherwise it would be used if the transforms
++ * require it. Don't cancel the 'valid' flag because this would prevent
++ * detection of duplicate chunks.
++ */
++ png_ptr->num_trans = 0;
++
++ if (info_ptr != NULL)
++ info_ptr->num_trans = 0;
++
++ png_chunk_benign_error(png_ptr, "tRNS must be after");
+ }
+ #endif
+
++#ifdef PNG_READ_hIST_SUPPORTED
++ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) != 0)
++ png_chunk_benign_error(png_ptr, "hIST must be after");
++#endif
++
++#ifdef PNG_READ_bKGD_SUPPORTED
++ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) != 0)
++ png_chunk_benign_error(png_ptr, "bKGD must be after");
++#endif
+ }
+
+ void /* PRIVATE */
+-png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_IEND(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_debug(1, "in png_handle_IEND");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
+- {
+- png_error(png_ptr, "No image in file");
+- }
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0 ||
++ (png_ptr->mode & PNG_HAVE_IDAT) == 0)
++ png_chunk_error(png_ptr, "out of place");
+
+ png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
+
++ png_crc_finish(png_ptr, length);
++
+ if (length != 0)
+- {
+- png_warning(png_ptr, "Incorrect IEND chunk length");
+- }
+-
+- png_crc_finish(png_ptr, length);
+-
+- PNG_UNUSED(info_ptr) /* Quiet compiler warnings about unused info_ptr */
++ png_chunk_benign_error(png_ptr, "invalid");
++
++ PNG_UNUSED(info_ptr)
+ }
+
+ #ifdef PNG_READ_gAMA_SUPPORTED
+ void /* PRIVATE */
+-png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_gAMA(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_fixed_point igamma;
+ png_byte buf[4];
+
+ png_debug(1, "in png_handle_gAMA");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before gAMA");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
+ {
+- png_warning(png_ptr, "Invalid gAMA after IDAT");
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
++ return;
++ }
++
++ if (length != 4)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
++ return;
++ }
++
++ png_crc_read(png_ptr, buf, 4);
++
++ if (png_crc_finish(png_ptr, 0) != 0)
++ return;
++
++ igamma = png_get_fixed_point(NULL, buf);
++
++ png_colorspace_set_gamma(png_ptr, &png_ptr->colorspace, igamma);
++ png_colorspace_sync(png_ptr, info_ptr);
++}
++#endif
++
++#ifdef PNG_READ_sBIT_SUPPORTED
++void /* PRIVATE */
++png_handle_sBIT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
++{
++ unsigned int truelen, i;
++ png_byte sample_depth;
++ png_byte buf[4];
++
++ png_debug(1, "in png_handle_sBIT");
++
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
++ return;
++ }
++
++ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) != 0)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
++ return;
++ }
++
++ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
++ {
++ truelen = 3;
++ sample_depth = 8;
++ }
++
++ else
++ {
++ truelen = png_ptr->channels;
++ sample_depth = png_ptr->bit_depth;
++ }
++
++ if (length != truelen || length > 4)
++ {
++ png_chunk_benign_error(png_ptr, "invalid");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+- else if (png_ptr->mode & PNG_HAVE_PLTE)
+- /* Should be an error, but we can cope with it */
+- png_warning(png_ptr, "Out of place gAMA chunk");
+-
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
+-#ifdef PNG_READ_sRGB_SUPPORTED
+- && !(info_ptr->valid & PNG_INFO_sRGB)
+-#endif
+- )
+- {
+- png_warning(png_ptr, "Duplicate gAMA chunk");
+- png_crc_finish(png_ptr, length);
++ buf[0] = buf[1] = buf[2] = buf[3] = sample_depth;
++ png_crc_read(png_ptr, buf, truelen);
++
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+- }
+-
+- if (length != 4)
+- {
+- png_warning(png_ptr, "Incorrect gAMA chunk length");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- png_crc_read(png_ptr, buf, 4);
+-
+- if (png_crc_finish(png_ptr, 0))
+- return;
+-
+- igamma = png_get_fixed_point(NULL, buf);
+-
+- /* Check for zero gamma or an error. */
+- if (igamma <= 0)
+- {
+- png_warning(png_ptr,
+- "Ignoring gAMA chunk with out of range gamma");
+-
+- return;
+- }
+-
+-# ifdef PNG_READ_sRGB_SUPPORTED
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))
+- {
+- if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))
++
++ for (i=0; i<truelen; ++i)
++ if (buf[i] == 0 || buf[i] > sample_depth)
+ {
+- PNG_WARNING_PARAMETERS(p)
+- png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_fixed, igamma);
+- png_formatted_warning(png_ptr, p,
+- "Ignoring incorrect gAMA value @1 when sRGB is also present");
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+- }
+-# endif /* PNG_READ_sRGB_SUPPORTED */
+-
+-# ifdef PNG_READ_GAMMA_SUPPORTED
+- /* Gamma correction on read is supported. */
+- png_ptr->gamma = igamma;
+-# endif
+- /* And set the 'info' structure members. */
+- png_set_gAMA_fixed(png_ptr, info_ptr, igamma);
+-}
+-#endif
+-
+-#ifdef PNG_READ_sBIT_SUPPORTED
+-void /* PRIVATE */
+-png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+-{
+- png_size_t truelen;
+- png_byte buf[4];
+-
+- png_debug(1, "in png_handle_sBIT");
+-
+- buf[0] = buf[1] = buf[2] = buf[3] = 0;
+-
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before sBIT");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
+- {
+- png_warning(png_ptr, "Invalid sBIT after IDAT");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- else if (png_ptr->mode & PNG_HAVE_PLTE)
+- {
+- /* Should be an error, but we can cope with it */
+- png_warning(png_ptr, "Out of place sBIT chunk");
+- }
+-
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))
+- {
+- png_warning(png_ptr, "Duplicate sBIT chunk");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+- truelen = 3;
+-
+- else
+- truelen = (png_size_t)png_ptr->channels;
+-
+- if (length != truelen || length > 4)
+- {
+- png_warning(png_ptr, "Incorrect sBIT chunk length");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- png_crc_read(png_ptr, buf, truelen);
+-
+- if (png_crc_finish(png_ptr, 0))
+- return;
+-
+- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
++
++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+ png_ptr->sig_bit.red = buf[0];
+ png_ptr->sig_bit.green = buf[1];
+@@ -950,377 +1204,416 @@
+
+ #ifdef PNG_READ_cHRM_SUPPORTED
+ void /* PRIVATE */
+-png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_cHRM(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_byte buf[32];
+- png_fixed_point x_white, y_white, x_red, y_red, x_green, y_green, x_blue,
+- y_blue;
++ png_xy xy;
+
+ png_debug(1, "in png_handle_cHRM");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before cHRM");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
+ {
+- png_warning(png_ptr, "Invalid cHRM after IDAT");
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
++ return;
++ }
++
++ if (length != 32)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
++ return;
++ }
++
++ png_crc_read(png_ptr, buf, 32);
++
++ if (png_crc_finish(png_ptr, 0) != 0)
++ return;
++
++ xy.whitex = png_get_fixed_point(NULL, buf);
++ xy.whitey = png_get_fixed_point(NULL, buf + 4);
++ xy.redx = png_get_fixed_point(NULL, buf + 8);
++ xy.redy = png_get_fixed_point(NULL, buf + 12);
++ xy.greenx = png_get_fixed_point(NULL, buf + 16);
++ xy.greeny = png_get_fixed_point(NULL, buf + 20);
++ xy.bluex = png_get_fixed_point(NULL, buf + 24);
++ xy.bluey = png_get_fixed_point(NULL, buf + 28);
++
++ if (xy.whitex == PNG_FIXED_ERROR ||
++ xy.whitey == PNG_FIXED_ERROR ||
++ xy.redx == PNG_FIXED_ERROR ||
++ xy.redy == PNG_FIXED_ERROR ||
++ xy.greenx == PNG_FIXED_ERROR ||
++ xy.greeny == PNG_FIXED_ERROR ||
++ xy.bluex == PNG_FIXED_ERROR ||
++ xy.bluey == PNG_FIXED_ERROR)
++ {
++ png_chunk_benign_error(png_ptr, "invalid values");
++ return;
++ }
++
++ /* If a colorspace error has already been output skip this chunk */
++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
++ return;
++
++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0)
++ {
++ 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_cHRM;
++ (void)png_colorspace_set_chromaticities(png_ptr, &png_ptr->colorspace, &xy,
++ 1/*prefer cHRM values*/);
++ png_colorspace_sync(png_ptr, info_ptr);
++}
++#endif
++
++#ifdef PNG_READ_sRGB_SUPPORTED
++void /* PRIVATE */
++png_handle_sRGB(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
++{
++ png_byte intent;
++
++ png_debug(1, "in png_handle_sRGB");
++
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
++ return;
++ }
++
++ if (length != 1)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
++ return;
++ }
++
++ png_crc_read(png_ptr, &intent, 1);
++
++ if (png_crc_finish(png_ptr, 0) != 0)
++ return;
++
++ /* If a colorspace error has already been output skip this chunk */
++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
++ return;
++
++ /* Only one sRGB or iCCP chunk is allowed, use the HAVE_INTENT flag to detect
++ * this.
++ */
++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) != 0)
++ {
++ png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
++ png_colorspace_sync(png_ptr, info_ptr);
++ png_chunk_benign_error(png_ptr, "too many profiles");
++ return;
++ }
++
++ (void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent);
++ png_colorspace_sync(png_ptr, info_ptr);
++}
++#endif /* READ_sRGB */
++
++#ifdef PNG_READ_iCCP_SUPPORTED
++void /* PRIVATE */
++png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
++/* Note: this does not properly handle profiles that are > 64K under DOS */
++{
++ png_const_charp errmsg = NULL; /* error message output, or no error */
++ int finished = 0; /* crc checked */
++
++ png_debug(1, "in png_handle_iCCP");
++
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
++ return;
++ }
++
++ /* Consistent with all the above colorspace handling an obviously *invalid*
++ * chunk is just ignored, so does not invalidate the color space. An
++ * alternative is to set the 'invalid' flags at the start of this routine
++ * and only clear them in they were not set before and all the tests pass.
++ * The minimum 'deflate' stream is assumed to be just the 2 byte header and
++ * 4 byte checksum. The keyword must be at least one character and there is
++ * a terminator (0) byte and the compression method.
++ */
++ if (length < 9)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "too short");
++ return;
++ }
++
++ /* If a colorspace error has already been output skip this chunk */
++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
++ {
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+- else if (png_ptr->mode & PNG_HAVE_PLTE)
+- /* Should be an error, but we can cope with it */
+- png_warning(png_ptr, "Missing PLTE before cHRM");
+-
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)
+-# ifdef PNG_READ_sRGB_SUPPORTED
+- && !(info_ptr->valid & PNG_INFO_sRGB)
+-# endif
+- )
++ /* Only one sRGB or iCCP chunk is allowed, use the HAVE_INTENT flag to detect
++ * this.
++ */
++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) == 0)
+ {
+- png_warning(png_ptr, "Duplicate cHRM chunk");
++ uInt read_length, keyword_length;
++ char keyword[81];
++
++ /* Find the keyword; the keyword plus separator and compression method
++ * bytes can be at most 81 characters long.
++ */
++ read_length = 81; /* maximum */
++ if (read_length > length)
++ read_length = (uInt)length;
++
++ png_crc_read(png_ptr, (png_bytep)keyword, read_length);
++ length -= read_length;
++
++ keyword_length = 0;
++ while (keyword_length < 80 && keyword_length < read_length &&
++ keyword[keyword_length] != 0)
++ ++keyword_length;
++
++ /* TODO: make the keyword checking common */
++ if (keyword_length >= 1 && keyword_length <= 79)
++ {
++ /* We only understand '0' compression - deflate - so if we get a
++ * different value we can't safely decode the chunk.
++ */
++ if (keyword_length+1 < read_length &&
++ keyword[keyword_length+1] == PNG_COMPRESSION_TYPE_BASE)
++ {
++ read_length -= keyword_length+2;
++
++ if (png_inflate_claim(png_ptr, png_iCCP) == Z_OK)
++ {
++ Byte profile_header[132];
++ Byte local_buffer[PNG_INFLATE_BUF_SIZE];
++ png_alloc_size_t size = (sizeof profile_header);
++
++ png_ptr->zstream.next_in = (Bytef*)keyword + (keyword_length+2);
++ png_ptr->zstream.avail_in = read_length;
++ (void)png_inflate_read(png_ptr, local_buffer,
++ (sizeof local_buffer), &length, profile_header, &size,
++ 0/*finish: don't, because the output is too small*/);
++
++ if (size == 0)
++ {
++ /* We have the ICC profile header; do the basic header checks.
++ */
++ const png_uint_32 profile_length =
++ png_get_uint_32(profile_header);
++
++ if (png_icc_check_length(png_ptr, &png_ptr->colorspace,
++ keyword, profile_length) != 0)
++ {
++ /* The length is apparently ok, so we can check the 132
++ * byte header.
++ */
++ if (png_icc_check_header(png_ptr, &png_ptr->colorspace,
++ keyword, profile_length, profile_header,
++ png_ptr->color_type) != 0)
++ {
++ /* Now read the tag table; a variable size buffer is
++ * needed at this point, allocate one for the whole
++ * profile. The header check has already validated
++ * that none of these stuff will overflow.
++ */
++ const png_uint_32 tag_count = png_get_uint_32(
++ profile_header+128);
++ png_bytep profile = png_read_buffer(png_ptr,
++ profile_length, 2/*silent*/);
++
++ if (profile != NULL)
++ {
++ memcpy(profile, profile_header,
++ (sizeof profile_header));
++
++ size = 12 * tag_count;
++
++ (void)png_inflate_read(png_ptr, local_buffer,
++ (sizeof local_buffer), &length,
++ profile + (sizeof profile_header), &size, 0);
++
++ /* Still expect a buffer error because we expect
++ * there to be some tag data!
++ */
++ if (size == 0)
++ {
++ if (png_icc_check_tag_table(png_ptr,
++ &png_ptr->colorspace, keyword, profile_length,
++ profile) != 0)
++ {
++ /* The profile has been validated for basic
++ * security issues, so read the whole thing in.
++ */
++ size = profile_length - (sizeof profile_header)
++ - 12 * tag_count;
++
++ (void)png_inflate_read(png_ptr, local_buffer,
++ (sizeof local_buffer), &length,
++ profile + (sizeof profile_header) +
++ 12 * tag_count, &size, 1/*finish*/);
++
++ if (length > 0 && !(png_ptr->flags &
++ PNG_FLAG_BENIGN_ERRORS_WARN))
++ errmsg = "extra compressed data";
++
++ /* But otherwise allow extra data: */
++ else if (size == 0)
++ {
++ if (length > 0)
++ {
++ /* This can be handled completely, so
++ * keep going.
++ */
++ png_chunk_warning(png_ptr,
++ "extra compressed data");
++ }
++
++ png_crc_finish(png_ptr, length);
++ finished = 1;
++
++# 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 (info_ptr != NULL)
++ {
++ png_free_data(png_ptr, info_ptr,
++ PNG_FREE_ICCP, 0);
++
++ info_ptr->iccp_name = png_voidcast(char*,
++ png_malloc_base(png_ptr,
++ keyword_length+1));
++ if (info_ptr->iccp_name != NULL)
++ {
++ memcpy(info_ptr->iccp_name, keyword,
++ keyword_length+1);
++ info_ptr->iccp_proflen =
++ profile_length;
++ info_ptr->iccp_profile = profile;
++ png_ptr->read_buffer = NULL; /*steal*/
++ info_ptr->free_me |= PNG_FREE_ICCP;
++ info_ptr->valid |= PNG_INFO_iCCP;
++ }
++
++ else
++ {
++ png_ptr->colorspace.flags |=
++ PNG_COLORSPACE_INVALID;
++ errmsg = "out of memory";
++ }
++ }
++
++ /* else the profile remains in the read
++ * buffer which gets reused for subsequent
++ * chunks.
++ */
++
++ if (info_ptr != NULL)
++ png_colorspace_sync(png_ptr, info_ptr);
++
++ if (errmsg == NULL)
++ {
++ png_ptr->zowner = 0;
++ return;
++ }
++ }
++
++ else if (size > 0)
++ errmsg = "truncated";
++
++ else
++ errmsg = png_ptr->zstream.msg;
++ }
++
++ /* else png_icc_check_tag_table output an error */
++ }
++
++ else /* profile truncated */
++ errmsg = png_ptr->zstream.msg;
++ }
++
++ else
++ errmsg = "out of memory";
++ }
++
++ /* else png_icc_check_header output an error */
++ }
++
++ /* else png_icc_check_length output an error */
++ }
++
++ else /* profile truncated */
++ errmsg = png_ptr->zstream.msg;
++
++ /* Release the stream */
++ png_ptr->zowner = 0;
++ }
++
++ else /* png_inflate_claim failed */
++ errmsg = png_ptr->zstream.msg;
++ }
++
++ else
++ errmsg = "bad compression method"; /* or missing */
++ }
++
++ else
++ errmsg = "bad keyword";
++ }
++
++ else
++ errmsg = "too many profiles";
++
++ /* Failure: the reason is in 'errmsg' */
++ if (finished == 0)
+ png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- if (length != 32)
+- {
+- png_warning(png_ptr, "Incorrect cHRM chunk length");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- png_crc_read(png_ptr, buf, 32);
+-
+- if (png_crc_finish(png_ptr, 0))
+- return;
+-
+- x_white = png_get_fixed_point(NULL, buf);
+- y_white = png_get_fixed_point(NULL, buf + 4);
+- x_red = png_get_fixed_point(NULL, buf + 8);
+- y_red = png_get_fixed_point(NULL, buf + 12);
+- x_green = png_get_fixed_point(NULL, buf + 16);
+- y_green = png_get_fixed_point(NULL, buf + 20);
+- x_blue = png_get_fixed_point(NULL, buf + 24);
+- y_blue = png_get_fixed_point(NULL, buf + 28);
+-
+- if (x_white == PNG_FIXED_ERROR ||
+- y_white == PNG_FIXED_ERROR ||
+- x_red == PNG_FIXED_ERROR ||
+- y_red == PNG_FIXED_ERROR ||
+- x_green == PNG_FIXED_ERROR ||
+- y_green == PNG_FIXED_ERROR ||
+- x_blue == PNG_FIXED_ERROR ||
+- y_blue == PNG_FIXED_ERROR)
+- {
+- png_warning(png_ptr, "Ignoring cHRM chunk with negative chromaticities");
+- return;
+- }
+-
+-#ifdef PNG_READ_sRGB_SUPPORTED
+- if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB))
+- {
+- if (PNG_OUT_OF_RANGE(x_white, 31270, 1000) ||
+- PNG_OUT_OF_RANGE(y_white, 32900, 1000) ||
+- PNG_OUT_OF_RANGE(x_red, 64000L, 1000) ||
+- PNG_OUT_OF_RANGE(y_red, 33000, 1000) ||
+- PNG_OUT_OF_RANGE(x_green, 30000, 1000) ||
+- PNG_OUT_OF_RANGE(y_green, 60000L, 1000) ||
+- PNG_OUT_OF_RANGE(x_blue, 15000, 1000) ||
+- PNG_OUT_OF_RANGE(y_blue, 6000, 1000))
+- {
+- PNG_WARNING_PARAMETERS(p)
+-
+- png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_fixed, x_white);
+- png_warning_parameter_signed(p, 2, PNG_NUMBER_FORMAT_fixed, y_white);
+- png_warning_parameter_signed(p, 3, PNG_NUMBER_FORMAT_fixed, x_red);
+- png_warning_parameter_signed(p, 4, PNG_NUMBER_FORMAT_fixed, y_red);
+- png_warning_parameter_signed(p, 5, PNG_NUMBER_FORMAT_fixed, x_green);
+- png_warning_parameter_signed(p, 6, PNG_NUMBER_FORMAT_fixed, y_green);
+- png_warning_parameter_signed(p, 7, PNG_NUMBER_FORMAT_fixed, x_blue);
+- png_warning_parameter_signed(p, 8, PNG_NUMBER_FORMAT_fixed, y_blue);
+-
+- png_formatted_warning(png_ptr, p,
+- "Ignoring incorrect cHRM white(@1,@2) r(@3,@4)g(@5,@6)b(@7,@8) "
+- "when sRGB is also present");
+- }
+- return;
+- }
+-#endif /* PNG_READ_sRGB_SUPPORTED */
+-
+-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+- /* Store the _white values as default coefficients for the rgb to gray
+- * operation if it is supported.
+- */
+- if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
+- {
+- /* png_set_background has not been called, the coefficients must be in
+- * range for the following to work without overflow.
+- */
+- if (y_red <= (1<<17) && y_green <= (1<<17) && y_blue <= (1<<17))
+- {
+- /* The y values are chromaticities: Y/X+Y+Z, the weights for the gray
+- * transformation are simply the normalized Y values for red, green and
+- * blue scaled by 32768.
+- */
+- png_uint_32 w = y_red + y_green + y_blue;
+-
+- png_ptr->rgb_to_gray_red_coeff = (png_uint_16)(((png_uint_32)y_red *
+- 32768)/w);
+- png_ptr->rgb_to_gray_green_coeff = (png_uint_16)(((png_uint_32)y_green
+- * 32768)/w);
+- png_ptr->rgb_to_gray_blue_coeff = (png_uint_16)(((png_uint_32)y_blue *
+- 32768)/w);
+- }
+- }
+-#endif
+-
+- png_set_cHRM_fixed(png_ptr, info_ptr, x_white, y_white, x_red, y_red,
+- x_green, y_green, x_blue, y_blue);
++
++ png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
++ png_colorspace_sync(png_ptr, info_ptr);
++ if (errmsg != NULL) /* else already output */
++ png_chunk_benign_error(png_ptr, errmsg);
+ }
+-#endif
+-
+-#ifdef PNG_READ_sRGB_SUPPORTED
++#endif /* READ_iCCP */
++
++#ifdef PNG_READ_sPLT_SUPPORTED
+ void /* PRIVATE */
+-png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+-{
+- int intent;
+- png_byte buf[1];
+-
+- png_debug(1, "in png_handle_sRGB");
+-
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before sRGB");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
+- {
+- png_warning(png_ptr, "Invalid sRGB after IDAT");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- else if (png_ptr->mode & PNG_HAVE_PLTE)
+- /* Should be an error, but we can cope with it */
+- png_warning(png_ptr, "Out of place sRGB chunk");
+-
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))
+- {
+- png_warning(png_ptr, "Duplicate sRGB chunk");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- if (length != 1)
+- {
+- png_warning(png_ptr, "Incorrect sRGB chunk length");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- png_crc_read(png_ptr, buf, 1);
+-
+- if (png_crc_finish(png_ptr, 0))
+- return;
+-
+- intent = buf[0];
+-
+- /* Check for bad intent */
+- if (intent >= PNG_sRGB_INTENT_LAST)
+- {
+- png_warning(png_ptr, "Unknown sRGB intent");
+- return;
+- }
+-
+-#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA))
+- {
+- if (PNG_OUT_OF_RANGE(info_ptr->gamma, 45500L, 500))
+- {
+- PNG_WARNING_PARAMETERS(p)
+-
+- png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_fixed,
+- info_ptr->gamma);
+-
+- png_formatted_warning(png_ptr, p,
+- "Ignoring incorrect gAMA value @1 when sRGB is also present");
+- }
+- }
+-#endif /* PNG_READ_gAMA_SUPPORTED */
+-
+-#ifdef PNG_READ_cHRM_SUPPORTED
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
+- if (PNG_OUT_OF_RANGE(info_ptr->x_white, 31270, 1000) ||
+- PNG_OUT_OF_RANGE(info_ptr->y_white, 32900, 1000) ||
+- PNG_OUT_OF_RANGE(info_ptr->x_red, 64000L, 1000) ||
+- PNG_OUT_OF_RANGE(info_ptr->y_red, 33000, 1000) ||
+- PNG_OUT_OF_RANGE(info_ptr->x_green, 30000, 1000) ||
+- PNG_OUT_OF_RANGE(info_ptr->y_green, 60000L, 1000) ||
+- PNG_OUT_OF_RANGE(info_ptr->x_blue, 15000, 1000) ||
+- PNG_OUT_OF_RANGE(info_ptr->y_blue, 6000, 1000))
+- {
+- png_warning(png_ptr,
+- "Ignoring incorrect cHRM value when sRGB is also present");
+- }
+-#endif /* PNG_READ_cHRM_SUPPORTED */
+-
+- png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);
+-}
+-#endif /* PNG_READ_sRGB_SUPPORTED */
+-
+-#ifdef PNG_READ_iCCP_SUPPORTED
+-void /* PRIVATE */
+-png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ /* Note: this does not properly handle chunks that are > 64K under DOS */
+ {
+- png_byte compression_type;
+- png_bytep pC;
+- png_charp profile;
+- png_uint_32 skip = 0;
+- png_uint_32 profile_size;
+- png_alloc_size_t profile_length;
+- png_size_t slength, prefix_length, data_length;
+-
+- png_debug(1, "in png_handle_iCCP");
+-
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before iCCP");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
+- {
+- png_warning(png_ptr, "Invalid iCCP after IDAT");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- else if (png_ptr->mode & PNG_HAVE_PLTE)
+- /* Should be an error, but we can cope with it */
+- png_warning(png_ptr, "Out of place iCCP chunk");
+-
+- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))
+- {
+- png_warning(png_ptr, "Duplicate iCCP chunk");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+-#ifdef PNG_MAX_MALLOC_64K
+- if (length > (png_uint_32)65535L)
+- {
+- png_warning(png_ptr, "iCCP chunk too large to fit in memory");
+- skip = length - (png_uint_32)65535L;
+- length = (png_uint_32)65535L;
+- }
+-#endif
+-
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
+- slength = (png_size_t)length;
+- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+-
+- if (png_crc_finish(png_ptr, skip))
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- png_ptr->chunkdata[slength] = 0x00;
+-
+- for (profile = png_ptr->chunkdata; *profile; profile++)
+- /* Empty loop to find end of name */ ;
+-
+- ++profile;
+-
+- /* There should be at least one zero (the compression type byte)
+- * following the separator, and we should be on it
+- */
+- if (profile >= png_ptr->chunkdata + slength - 1)
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- png_warning(png_ptr, "Malformed iCCP chunk");
+- return;
+- }
+-
+- /* Compression_type should always be zero */
+- compression_type = *profile++;
+-
+- if (compression_type)
+- {
+- png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");
+- compression_type = 0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8
+- wrote nonzero) */
+- }
+-
+- prefix_length = profile - png_ptr->chunkdata;
+- png_decompress_chunk(png_ptr, compression_type,
+- slength, prefix_length, &data_length);
+-
+- profile_length = data_length - prefix_length;
+-
+- if (prefix_length > data_length || profile_length < 4)
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- png_warning(png_ptr, "Profile size field missing from iCCP chunk");
+- return;
+- }
+-
+- /* Check the profile_size recorded in the first 32 bits of the ICC profile */
+- pC = (png_bytep)(png_ptr->chunkdata + prefix_length);
+- profile_size = ((*(pC )) << 24) |
+- ((*(pC + 1)) << 16) |
+- ((*(pC + 2)) << 8) |
+- ((*(pC + 3)) );
+-
+- /* NOTE: the following guarantees that 'profile_length' fits into 32 bits,
+- * because profile_size is a 32 bit value.
+- */
+- if (profile_size < profile_length)
+- profile_length = profile_size;
+-
+- /* And the following guarantees that profile_size == profile_length. */
+- if (profile_size > profile_length)
+- {
+- PNG_WARNING_PARAMETERS(p)
+-
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+-
+- png_warning_parameter_unsigned(p, 1, PNG_NUMBER_FORMAT_u, profile_size);
+- png_warning_parameter_unsigned(p, 2, PNG_NUMBER_FORMAT_u, profile_length);
+- png_formatted_warning(png_ptr, p,
+- "Ignoring iCCP chunk with declared size = @1 and actual length = @2");
+- return;
+- }
+-
+- png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,
+- compression_type, (png_bytep)png_ptr->chunkdata + prefix_length,
+- profile_size);
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+-}
+-#endif /* PNG_READ_iCCP_SUPPORTED */
+-
+-#ifdef PNG_READ_sPLT_SUPPORTED
+-void /* PRIVATE */
+-png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+-/* Note: this does not properly handle chunks that are > 64K under DOS */
+-{
+- png_bytep entry_start;
++ png_bytep entry_start, buffer;
+ png_sPLT_t new_palette;
+ png_sPLT_entryp pp;
+ png_uint_32 data_length;
+ int entry_size, i;
+ png_uint_32 skip = 0;
+- png_size_t slength;
+ png_uint_32 dl;
+ png_size_t max_dl;
+
+ png_debug(1, "in png_handle_sPLT");
+
+ #ifdef PNG_USER_LIMITS_SUPPORTED
+-
+ if (png_ptr->user_chunk_cache_max != 0)
+ {
+ if (png_ptr->user_chunk_cache_max == 1)
+@@ -1338,55 +1631,53 @@
+ }
+ #endif
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before sPLT");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ {
+- png_warning(png_ptr, "Invalid sPLT after IDAT");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+ #ifdef PNG_MAX_MALLOC_64K
+- if (length > (png_uint_32)65535L)
++ if (length > 65535U)
+ {
+- png_warning(png_ptr, "sPLT chunk too large to fit in memory");
+- skip = length - (png_uint_32)65535L;
+- length = (png_uint_32)65535L;
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "too large to fit in memory");
++ return;
+ }
+ #endif
+
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
++ buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
++ if (buffer == NULL)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of memory");
++ return;
++ }
++
+
+ /* WARNING: this may break if size_t is less than 32 bits; it is assumed
+ * that the PNG_MAX_MALLOC_64K test is enabled in this case, but this is a
+ * potential breakage point if the types in pngconf.h aren't exactly right.
+ */
+- slength = (png_size_t)length;
+- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+-
+- if (png_crc_finish(png_ptr, skip))
++ png_crc_read(png_ptr, buffer, length);
++
++ if (png_crc_finish(png_ptr, skip) != 0)
++ return;
++
++ buffer[length] = 0;
++
++ for (entry_start = buffer; *entry_start; entry_start++)
++ /* Empty loop to find end of name */ ;
++
++ ++entry_start;
++
++ /* A sample depth should follow the separator, and we should be on it */
++ if (entry_start > buffer + length - 2)
+ {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- png_ptr->chunkdata[slength] = 0x00;
+-
+- for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start;
+- entry_start++)
+- /* Empty loop to find end of name */ ;
+-
+- ++entry_start;
+-
+- /* A sample depth should follow the separator, and we should be on it */
+- if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "malformed sPLT chunk");
+ return;
+ }
+@@ -1394,23 +1685,19 @@
+ new_palette.depth = *entry_start++;
+ entry_size = (new_palette.depth == 8 ? 6 : 10);
+ /* This must fit in a png_uint_32 because it is derived from the original
+- * chunk data length (and use 'length', not 'slength' here for clarity -
+- * they are guaranteed to be the same, see the tests above.)
++ * chunk data length.
+ */
+- data_length = length - (png_uint_32)(entry_start -
+- (png_bytep)png_ptr->chunkdata);
++ data_length = length - (png_uint_32)(entry_start - buffer);
+
+ /* Integrity-check the data length */
+- if (data_length % entry_size)
++ if ((data_length % entry_size) != 0)
+ {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+ png_warning(png_ptr, "sPLT chunk has bad length");
+ return;
+ }
+
+ dl = (png_int_32)(data_length / entry_size);
+- max_dl = PNG_SIZE_MAX / png_sizeof(png_sPLT_entry);
++ max_dl = PNG_SIZE_MAX / (sizeof (png_sPLT_entry));
+
+ if (dl > max_dl)
+ {
+@@ -1421,7 +1708,7 @@
+ new_palette.nentries = (png_int_32)(data_length / entry_size);
+
+ new_palette.entries = (png_sPLT_entryp)png_malloc_warn(
+- png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));
++ png_ptr, new_palette.nentries * (sizeof (png_sPLT_entry)));
+
+ if (new_palette.entries == NULL)
+ {
+@@ -1479,38 +1766,36 @@
+ #endif
+
+ /* Discard all chunk data except the name and stash that */
+- new_palette.name = png_ptr->chunkdata;
++ new_palette.name = (png_charp)buffer;
+
+ png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
+
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+ png_free(png_ptr, new_palette.entries);
+ }
+-#endif /* PNG_READ_sPLT_SUPPORTED */
++#endif /* READ_sPLT */
+
+ #ifdef PNG_READ_tRNS_SUPPORTED
+ void /* PRIVATE */
+-png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_tRNS(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_byte readbuf[PNG_MAX_PALETTE_LENGTH];
+
+ png_debug(1, "in png_handle_tRNS");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before tRNS");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ {
+- png_warning(png_ptr, "Invalid tRNS after IDAT");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS) != 0)
+ {
+- png_warning(png_ptr, "Duplicate tRNS chunk");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
+ return;
+ }
+
+@@ -1520,8 +1805,8 @@
+
+ if (length != 2)
+ {
+- png_warning(png_ptr, "Incorrect tRNS chunk length");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+@@ -1536,12 +1821,12 @@
+
+ if (length != 6)
+ {
+- png_warning(png_ptr, "Incorrect tRNS chunk length");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+- png_crc_read(png_ptr, buf, (png_size_t)length);
++ png_crc_read(png_ptr, buf, length);
+ png_ptr->num_trans = 1;
+ png_ptr->trans_color.red = png_get_uint_16(buf);
+ png_ptr->trans_color.green = png_get_uint_16(buf + 2);
+@@ -1550,44 +1835,43 @@
+
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+- if (!(png_ptr->mode & PNG_HAVE_PLTE))
++ if ((png_ptr->mode & PNG_HAVE_PLTE) == 0)
+ {
+- /* Should be an error, but we can cope with it. */
+- png_warning(png_ptr, "Missing PLTE before tRNS");
+- }
+-
+- if (length > (png_uint_32)png_ptr->num_palette ||
+- length > PNG_MAX_PALETTE_LENGTH)
+- {
+- png_warning(png_ptr, "Incorrect tRNS chunk length");
++ /* TODO: is this actually an error in the ISO spec? */
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- if (length == 0)
++ if (length > png_ptr->num_palette || length > PNG_MAX_PALETTE_LENGTH ||
++ length == 0)
+ {
+- png_warning(png_ptr, "Zero length tRNS chunk");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+- png_crc_read(png_ptr, readbuf, (png_size_t)length);
++ png_crc_read(png_ptr, readbuf, length);
+ png_ptr->num_trans = (png_uint_16)length;
+ }
+
+ else
+ {
+- png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid with alpha channel");
+ return;
+ }
+
+- if (png_crc_finish(png_ptr, 0))
++ if (png_crc_finish(png_ptr, 0) != 0)
+ {
+ png_ptr->num_trans = 0;
+ return;
+ }
+
++ /* TODO: this is a horrible side effect in the palette case because the
++ * png_struct ends up with a pointer to the tRNS buffer owned by the
++ * png_info. Fix this.
++ */
+ png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
+ &(png_ptr->trans_color));
+ }
+@@ -1595,58 +1879,52 @@
+
+ #ifdef PNG_READ_bKGD_SUPPORTED
+ void /* PRIVATE */
+-png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_bKGD(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+- png_size_t truelen;
++ unsigned int truelen;
+ png_byte buf[6];
+ png_color_16 background;
+
+ png_debug(1, "in png_handle_bKGD");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before bKGD");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0 ||
++ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
++ (png_ptr->mode & PNG_HAVE_PLTE) == 0))
+ {
+- png_warning(png_ptr, "Invalid bKGD after IDAT");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+- !(png_ptr->mode & PNG_HAVE_PLTE))
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) != 0)
+ {
+- png_warning(png_ptr, "Missing PLTE before bKGD");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
+ return;
+ }
+
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))
++ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
++ truelen = 1;
++
++ else if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
++ truelen = 6;
++
++ else
++ truelen = 2;
++
++ if (length != truelen)
+ {
+- png_warning(png_ptr, "Duplicate bKGD chunk");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+- truelen = 1;
+-
+- else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
+- truelen = 6;
+-
+- else
+- truelen = 2;
+-
+- if (length != truelen)
+- {
+- png_warning(png_ptr, "Incorrect bKGD chunk length");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+ png_crc_read(png_ptr, buf, truelen);
+
+- if (png_crc_finish(png_ptr, 0))
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+
+ /* We convert the index value into RGB components so that we can allow
+@@ -1658,11 +1936,11 @@
+ {
+ background.index = buf[0];
+
+- if (info_ptr && info_ptr->num_palette)
++ if (info_ptr != NULL && info_ptr->num_palette != 0)
+ {
+ if (buf[0] >= info_ptr->num_palette)
+ {
+- png_warning(png_ptr, "Incorrect bKGD chunk index value");
++ png_chunk_benign_error(png_ptr, "invalid index");
+ return;
+ }
+
+@@ -1677,7 +1955,7 @@
+ background.gray = 0;
+ }
+
+- else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
++ else if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0) /* GRAY */
+ {
+ background.index = 0;
+ background.red =
+@@ -1701,44 +1979,37 @@
+
+ #ifdef PNG_READ_hIST_SUPPORTED
+ void /* PRIVATE */
+-png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_hIST(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ unsigned int num, i;
+ png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];
+
+ png_debug(1, "in png_handle_hIST");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before hIST");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0 ||
++ (png_ptr->mode & PNG_HAVE_PLTE) == 0)
+ {
+- png_warning(png_ptr, "Invalid hIST after IDAT");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- else if (!(png_ptr->mode & PNG_HAVE_PLTE))
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) != 0)
+ {
+- png_warning(png_ptr, "Missing PLTE before hIST");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
+ return;
+ }
+
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))
++ num = length / 2 ;
++
++ if (num != png_ptr->num_palette || num > PNG_MAX_PALETTE_LENGTH)
+ {
+- png_warning(png_ptr, "Duplicate hIST chunk");
+ png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- num = length / 2 ;
+-
+- if (num != (unsigned int)png_ptr->num_palette || num >
+- (unsigned int)PNG_MAX_PALETTE_LENGTH)
+- {
+- png_warning(png_ptr, "Incorrect hIST chunk length");
+- png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+@@ -1750,7 +2021,7 @@
+ readbuf[i] = png_get_uint_16(buf);
+ }
+
+- if (png_crc_finish(png_ptr, 0))
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+
+ png_set_hIST(png_ptr, info_ptr, readbuf);
+@@ -1759,7 +2030,7 @@
+
+ #ifdef PNG_READ_pHYs_SUPPORTED
+ void /* PRIVATE */
+-png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_pHYs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_byte buf[9];
+ png_uint_32 res_x, res_y;
+@@ -1767,33 +2038,33 @@
+
+ png_debug(1, "in png_handle_pHYs");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before pHYs");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ {
+- png_warning(png_ptr, "Invalid pHYs after IDAT");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs) != 0)
+ {
+- png_warning(png_ptr, "Duplicate pHYs chunk");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
+ return;
+ }
+
+ if (length != 9)
+ {
+- png_warning(png_ptr, "Incorrect pHYs chunk length");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 9);
+
+- if (png_crc_finish(png_ptr, 0))
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+
+ res_x = png_get_uint_32(buf);
+@@ -1805,7 +2076,7 @@
+
+ #ifdef PNG_READ_oFFs_SUPPORTED
+ void /* PRIVATE */
+-png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_oFFs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_byte buf[9];
+ png_int_32 offset_x, offset_y;
+@@ -1813,33 +2084,33 @@
+
+ png_debug(1, "in png_handle_oFFs");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before oFFs");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ {
+- png_warning(png_ptr, "Invalid oFFs after IDAT");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) != 0)
+ {
+- png_warning(png_ptr, "Duplicate oFFs chunk");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
+ return;
+ }
+
+ if (length != 9)
+ {
+- png_warning(png_ptr, "Incorrect oFFs chunk length");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 9);
+
+- if (png_crc_finish(png_ptr, 0))
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+
+ offset_x = png_get_int_32(buf);
+@@ -1852,71 +2123,64 @@
+ #ifdef PNG_READ_pCAL_SUPPORTED
+ /* Read the pCAL chunk (described in the PNG Extensions document) */
+ void /* PRIVATE */
+-png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_pCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_int_32 X0, X1;
+ png_byte type, nparams;
+- png_charp buf, units, endptr;
++ png_bytep buffer, buf, units, endptr;
+ png_charpp params;
+- png_size_t slength;
+ int i;
+
+ png_debug(1, "in png_handle_pCAL");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before pCAL");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ {
+- png_warning(png_ptr, "Invalid pCAL after IDAT");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
+ return;
+ }
+
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) != 0)
+ {
+- png_warning(png_ptr, "Duplicate pCAL chunk");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
+ return;
+ }
+
+ png_debug1(2, "Allocating and reading pCAL chunk data (%u bytes)",
+ length + 1);
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+-
+- if (png_ptr->chunkdata == NULL)
++
++ buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
++
++ if (buffer == NULL)
+ {
+- png_warning(png_ptr, "No memory for pCAL purpose");
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of memory");
+ return;
+ }
+
+- slength = (png_size_t)length;
+- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+-
+- if (png_crc_finish(png_ptr, 0))
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
++ png_crc_read(png_ptr, buffer, length);
++
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+- }
+-
+- png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
++
++ buffer[length] = 0; /* Null terminate the last string */
+
+ png_debug(3, "Finding end of pCAL purpose string");
+- for (buf = png_ptr->chunkdata; *buf; buf++)
++ for (buf = buffer; *buf; buf++)
+ /* Empty loop */ ;
+
+- endptr = png_ptr->chunkdata + slength;
++ endptr = buffer + length;
+
+ /* We need to have at least 12 bytes after the purpose string
+ * in order to get the parameter information.
+ */
+ if (endptr <= buf + 12)
+ {
+- png_warning(png_ptr, "Invalid pCAL data");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+@@ -1936,15 +2200,13 @@
+ (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||
+ (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))
+ {
+- png_warning(png_ptr, "Invalid pCAL parameters for equation type");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
++ png_chunk_benign_error(png_ptr, "invalid parameter count");
+ return;
+ }
+
+ else if (type >= PNG_EQUATION_LAST)
+ {
+- png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
++ png_chunk_benign_error(png_ptr, "unrecognized equation type");
+ }
+
+ for (buf = units; *buf; buf++)
+@@ -1952,43 +2214,37 @@
+
+ png_debug(3, "Allocating pCAL parameters array");
+
+- params = (png_charpp)png_malloc_warn(png_ptr,
+- (png_size_t)(nparams * png_sizeof(png_charp)));
++ params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
++ nparams * (sizeof (png_charp))));
+
+ if (params == NULL)
+ {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- png_warning(png_ptr, "No memory for pCAL params");
++ png_chunk_benign_error(png_ptr, "out of memory");
+ return;
+ }
+
+ /* Get pointers to the start of each parameter string. */
+- for (i = 0; i < (int)nparams; i++)
++ for (i = 0; i < nparams; i++)
+ {
+ buf++; /* Skip the null string terminator from previous parameter. */
+
+ png_debug1(3, "Reading pCAL parameter %d", i);
+
+- for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++)
++ for (params[i] = (png_charp)buf; buf <= endptr && *buf != 0; buf++)
+ /* Empty loop to move past each parameter string */ ;
+
+ /* Make sure we haven't run out of data yet */
+ if (buf > endptr)
+ {
+- png_warning(png_ptr, "Invalid pCAL data");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+ png_free(png_ptr, params);
++ png_chunk_benign_error(png_ptr, "invalid data");
+ return;
+ }
+ }
+
+- png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,
+- units, params);
+-
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
++ png_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams,
++ (png_charp)units, params);
++
+ png_free(png_ptr, params);
+ }
+ #endif
+@@ -1996,67 +2252,61 @@
+ #ifdef PNG_READ_sCAL_SUPPORTED
+ /* Read the sCAL chunk */
+ void /* PRIVATE */
+-png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+- png_size_t slength, i;
++ png_bytep buffer;
++ png_size_t i;
+ int state;
+
+ png_debug(1, "in png_handle_sCAL");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before sCAL");
+-
+- else if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ {
+- png_warning(png_ptr, "Invalid sCAL after IDAT");
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of place");
++ return;
++ }
++
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL) != 0)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
++ return;
++ }
++
++ /* Need unit type, width, \0, height: minimum 4 bytes */
++ else if (length < 4)
++ {
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
++ return;
++ }
++
++ png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)",
++ length + 1);
++
++ buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
++
++ if (buffer == NULL)
++ {
++ png_chunk_benign_error(png_ptr, "out of memory");
+ png_crc_finish(png_ptr, length);
+ return;
+ }
+
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))
++ png_crc_read(png_ptr, buffer, length);
++ buffer[length] = 0; /* Null terminate the last string */
++
++ if (png_crc_finish(png_ptr, 0) != 0)
++ return;
++
++ /* Validate the unit. */
++ if (buffer[0] != 1 && buffer[0] != 2)
+ {
+- png_warning(png_ptr, "Duplicate sCAL chunk");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- /* Need unit type, width, \0, height: minimum 4 bytes */
+- else if (length < 4)
+- {
+- png_warning(png_ptr, "sCAL chunk too short");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)",
+- length + 1);
+-
+- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+-
+- if (png_ptr->chunkdata == NULL)
+- {
+- png_warning(png_ptr, "Out of memory while processing sCAL chunk");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- slength = (png_size_t)length;
+- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+- png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
+-
+- if (png_crc_finish(png_ptr, 0))
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- /* Validate the unit. */
+- if (png_ptr->chunkdata[0] != 1 && png_ptr->chunkdata[0] != 2)
+- {
+- png_warning(png_ptr, "Invalid sCAL ignored: invalid unit");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
++ png_chunk_benign_error(png_ptr, "invalid unit");
+ return;
+ }
+
+@@ -2066,70 +2316,65 @@
+ i = 1;
+ state = 0;
+
+- if (!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) ||
+- i >= slength || png_ptr->chunkdata[i++] != 0)
+- png_warning(png_ptr, "Invalid sCAL chunk ignored: bad width format");
+-
+- else if (!PNG_FP_IS_POSITIVE(state))
+- png_warning(png_ptr, "Invalid sCAL chunk ignored: non-positive width");
++ if (png_check_fp_number((png_const_charp)buffer, length, &state, &i) == 0 ||
++ i >= length || buffer[i++] != 0)
++ png_chunk_benign_error(png_ptr, "bad width format");
++
++ else if (PNG_FP_IS_POSITIVE(state) == 0)
++ png_chunk_benign_error(png_ptr, "non-positive width");
+
+ else
+ {
+ png_size_t heighti = i;
+
+ state = 0;
+- if (!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) ||
+- i != slength)
+- png_warning(png_ptr, "Invalid sCAL chunk ignored: bad height format");
+-
+- else if (!PNG_FP_IS_POSITIVE(state))
+- png_warning(png_ptr,
+- "Invalid sCAL chunk ignored: non-positive height");
++ if (png_check_fp_number((png_const_charp)buffer, length,
++ &state, &i) == 0 || i != length)
++ png_chunk_benign_error(png_ptr, "bad height format");
++
++ else if (PNG_FP_IS_POSITIVE(state) == 0)
++ png_chunk_benign_error(png_ptr, "non-positive height");
+
+ else
+ /* This is the (only) success case. */
+- png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0],
+- png_ptr->chunkdata+1, png_ptr->chunkdata+heighti);
++ png_set_sCAL_s(png_ptr, info_ptr, buffer[0],
++ (png_charp)buffer+1, (png_charp)buffer+heighti);
+ }
+-
+- /* Clean up - just free the temporarily allocated buffer. */
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+ }
+ #endif
+
+ #ifdef PNG_READ_tIME_SUPPORTED
+ void /* PRIVATE */
+-png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_tIME(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+ png_byte buf[7];
+ png_time mod_time;
+
+ png_debug(1, "in png_handle_tIME");
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Out of place tIME chunk");
+-
+- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) != 0)
+ {
+- png_warning(png_ptr, "Duplicate tIME chunk");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "duplicate");
+ return;
+ }
+
+- if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+ if (length != 7)
+ {
+- png_warning(png_ptr, "Incorrect tIME chunk length");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "invalid");
+ return;
+ }
+
+ png_crc_read(png_ptr, buf, 7);
+
+- if (png_crc_finish(png_ptr, 0))
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+
+ mod_time.second = buf[6];
+@@ -2146,14 +2391,13 @@
+ #ifdef PNG_READ_tEXt_SUPPORTED
+ /* Note: this does not properly handle chunks that are > 64K under DOS */
+ void /* PRIVATE */
+-png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_tEXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+- png_textp text_ptr;
++ png_text text_info;
++ png_bytep buffer;
+ png_charp key;
+ png_charp text;
+ png_uint_32 skip = 0;
+- png_size_t slength;
+- int ret;
+
+ png_debug(1, "in png_handle_tEXt");
+
+@@ -2168,84 +2412,59 @@
+
+ if (--png_ptr->user_chunk_cache_max == 1)
+ {
+- png_warning(png_ptr, "No space in chunk cache for tEXt");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "no space in chunk cache");
+ return;
+ }
+ }
+ #endif
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before tEXt");
+-
+- if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+ #ifdef PNG_MAX_MALLOC_64K
+- if (length > (png_uint_32)65535L)
++ if (length > 65535U)
+ {
+- png_warning(png_ptr, "tEXt chunk too large to fit in memory");
+- skip = length - (png_uint_32)65535L;
+- length = (png_uint_32)65535L;
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "too large to fit in memory");
++ return;
+ }
+ #endif
+
+- png_free(png_ptr, png_ptr->chunkdata);
+-
+- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+-
+- if (png_ptr->chunkdata == NULL)
++ buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
++
++ if (buffer == NULL)
+ {
+- png_warning(png_ptr, "No memory to process text chunk");
++ png_chunk_benign_error(png_ptr, "out of memory");
+ return;
+ }
+
+- slength = (png_size_t)length;
+- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+-
+- if (png_crc_finish(png_ptr, skip))
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
++ png_crc_read(png_ptr, buffer, length);
++
++ if (png_crc_finish(png_ptr, skip) != 0)
+ return;
+- }
+-
+- key = png_ptr->chunkdata;
+-
+- key[slength] = 0x00;
++
++ key = (png_charp)buffer;
++ key[length] = 0;
+
+ for (text = key; *text; text++)
+ /* Empty loop to find end of key */ ;
+
+- if (text != key + slength)
++ if (text != key + length)
+ text++;
+
+- text_ptr = (png_textp)png_malloc_warn(png_ptr,
+- png_sizeof(png_text));
+-
+- if (text_ptr == NULL)
+- {
+- png_warning(png_ptr, "Not enough memory to process text chunk");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
+- text_ptr->key = key;
+- text_ptr->lang = NULL;
+- text_ptr->lang_key = NULL;
+- text_ptr->itxt_length = 0;
+- text_ptr->text = text;
+- text_ptr->text_length = png_strlen(text);
+-
+- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+-
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- png_free(png_ptr, text_ptr);
+-
+- if (ret)
++ text_info.compression = PNG_TEXT_COMPRESSION_NONE;
++ text_info.key = key;
++ text_info.lang = NULL;
++ text_info.lang_key = NULL;
++ text_info.itxt_length = 0;
++ text_info.text = text;
++ text_info.text_length = strlen(text);
++
++ if (png_set_text_2(png_ptr, info_ptr, &text_info, 1) != 0)
+ png_warning(png_ptr, "Insufficient memory to process text chunk");
+ }
+ #endif
+@@ -2253,13 +2472,11 @@
+ #ifdef PNG_READ_zTXt_SUPPORTED
+ /* Note: this does not correctly handle chunks that are > 64K under DOS */
+ void /* PRIVATE */
+-png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_zTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+- png_textp text_ptr;
+- png_charp text;
+- int comp_type;
+- int ret;
+- png_size_t slength, prefix_len, data_len;
++ png_const_charp errmsg = NULL;
++ png_bytep buffer;
++ png_uint_32 keyword_length;
+
+ png_debug(1, "in png_handle_zTXt");
+
+@@ -2274,123 +2491,101 @@
+
+ if (--png_ptr->user_chunk_cache_max == 1)
+ {
+- png_warning(png_ptr, "No space in chunk cache for zTXt");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "no space in chunk cache");
+ return;
+ }
+ }
+ #endif
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before zTXt");
+-
+- if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+-#ifdef PNG_MAX_MALLOC_64K
+- /* We will no doubt have problems with chunks even half this size, but
+- * there is no hard and fast rule to tell us where to stop.
+- */
+- if (length > (png_uint_32)65535L)
++ buffer = png_read_buffer(png_ptr, length, 2/*silent*/);
++
++ if (buffer == NULL)
+ {
+- png_warning(png_ptr, "zTXt chunk too large to fit in memory");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of memory");
+ return;
+ }
+-#endif
+-
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+-
+- if (png_ptr->chunkdata == NULL)
+- {
+- png_warning(png_ptr, "Out of memory processing zTXt chunk");
++
++ png_crc_read(png_ptr, buffer, length);
++
++ if (png_crc_finish(png_ptr, 0) != 0)
+ return;
+- }
+-
+- slength = (png_size_t)length;
+- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+-
+- if (png_crc_finish(png_ptr, 0))
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- png_ptr->chunkdata[slength] = 0x00;
+-
+- for (text = png_ptr->chunkdata; *text; text++)
+- /* Empty loop */ ;
+-
+- /* zTXt must have some text after the chunkdataword */
+- if (text >= png_ptr->chunkdata + slength - 2)
+- {
+- png_warning(png_ptr, "Truncated zTXt chunk");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
++
++ /* TODO: also check that the keyword contents match the spec! */
++ for (keyword_length = 0;
++ keyword_length < length && buffer[keyword_length] != 0;
++ ++keyword_length)
++ /* Empty loop to find end of name */ ;
++
++ if (keyword_length > 79 || keyword_length < 1)
++ errmsg = "bad keyword";
++
++ /* zTXt must have some LZ data after the keyword, although it may expand to
++ * zero bytes; we need a '\0' at the end of the keyword, the compression type
++ * then the LZ data:
++ */
++ else if (keyword_length + 3 > length)
++ errmsg = "truncated";
++
++ else if (buffer[keyword_length+1] != PNG_COMPRESSION_TYPE_BASE)
++ errmsg = "unknown compression type";
+
+ else
+ {
+- comp_type = *(++text);
+-
+- if (comp_type != PNG_TEXT_COMPRESSION_zTXt)
+- {
+- png_warning(png_ptr, "Unknown compression type in zTXt chunk");
+- comp_type = PNG_TEXT_COMPRESSION_zTXt;
+- }
+-
+- text++; /* Skip the compression_method byte */
++ png_alloc_size_t uncompressed_length = PNG_SIZE_MAX;
++
++ /* TODO: at present png_decompress_chunk imposes a single application
++ * level memory limit, this should be split to different values for iCCP
++ * and text chunks.
++ */
++ if (png_decompress_chunk(png_ptr, length, keyword_length+2,
++ &uncompressed_length, 1/*terminate*/) == Z_STREAM_END)
++ {
++ png_text text;
++
++ /* It worked; png_ptr->read_buffer now looks like a tEXt chunk except
++ * for the extra compression type byte and the fact that it isn't
++ * necessarily '\0' terminated.
++ */
++ buffer = png_ptr->read_buffer;
++ buffer[uncompressed_length+(keyword_length+2)] = 0;
++
++ text.compression = PNG_TEXT_COMPRESSION_zTXt;
++ text.key = (png_charp)buffer;
++ text.text = (png_charp)(buffer + keyword_length+2);
++ text.text_length = uncompressed_length;
++ text.itxt_length = 0;
++ text.lang = NULL;
++ text.lang_key = NULL;
++
++ if (png_set_text_2(png_ptr, info_ptr, &text, 1) != 0)
++ errmsg = "insufficient memory";
++ }
++
++ else
++ errmsg = png_ptr->zstream.msg;
+ }
+
+- prefix_len = text - png_ptr->chunkdata;
+-
+- png_decompress_chunk(png_ptr, comp_type,
+- (png_size_t)length, prefix_len, &data_len);
+-
+- text_ptr = (png_textp)png_malloc_warn(png_ptr,
+- png_sizeof(png_text));
+-
+- if (text_ptr == NULL)
+- {
+- png_warning(png_ptr, "Not enough memory to process zTXt chunk");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- text_ptr->compression = comp_type;
+- text_ptr->key = png_ptr->chunkdata;
+- text_ptr->lang = NULL;
+- text_ptr->lang_key = NULL;
+- text_ptr->itxt_length = 0;
+- text_ptr->text = png_ptr->chunkdata + prefix_len;
+- text_ptr->text_length = data_len;
+-
+- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+-
+- png_free(png_ptr, text_ptr);
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+-
+- if (ret)
+- png_error(png_ptr, "Insufficient memory to store zTXt chunk");
++ if (errmsg != NULL)
++ png_chunk_benign_error(png_ptr, errmsg);
+ }
+ #endif
+
+ #ifdef PNG_READ_iTXt_SUPPORTED
+ /* Note: this does not correctly handle chunks that are > 64K under DOS */
+ void /* PRIVATE */
+-png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++png_handle_iTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
+ {
+- png_textp text_ptr;
+- png_charp key, lang, text, lang_key;
+- int comp_flag;
+- int comp_type = 0;
+- int ret;
+- png_size_t slength, prefix_len, data_len;
++ png_const_charp errmsg = NULL;
++ png_bytep buffer;
++ png_uint_32 prefix_length;
+
+ png_debug(1, "in png_handle_iTXt");
+
+@@ -2405,274 +2600,393 @@
+
+ if (--png_ptr->user_chunk_cache_max == 1)
+ {
+- png_warning(png_ptr, "No space in chunk cache for iTXt");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "no space in chunk cache");
+ return;
+ }
+ }
+ #endif
+
+- if (!(png_ptr->mode & PNG_HAVE_IHDR))
+- png_error(png_ptr, "Missing IHDR before iTXt");
+-
+- if (png_ptr->mode & PNG_HAVE_IDAT)
++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
++ png_chunk_error(png_ptr, "missing IHDR");
++
++ if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+ png_ptr->mode |= PNG_AFTER_IDAT;
+
+-#ifdef PNG_MAX_MALLOC_64K
+- /* We will no doubt have problems with chunks even half this size, but
+- * there is no hard and fast rule to tell us where to stop.
+- */
+- if (length > (png_uint_32)65535L)
++ buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
++
++ if (buffer == NULL)
+ {
+- png_warning(png_ptr, "iTXt chunk too large to fit in memory");
+ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "out of memory");
+ return;
+ }
+-#endif
+-
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
+-
+- if (png_ptr->chunkdata == NULL)
++
++ png_crc_read(png_ptr, buffer, length);
++
++ if (png_crc_finish(png_ptr, 0) != 0)
++ return;
++
++ /* First the keyword. */
++ for (prefix_length=0;
++ prefix_length < length && buffer[prefix_length] != 0;
++ ++prefix_length)
++ /* Empty loop */ ;
++
++ /* Perform a basic check on the keyword length here. */
++ if (prefix_length > 79 || prefix_length < 1)
++ errmsg = "bad keyword";
++
++ /* Expect keyword, compression flag, compression type, language, translated
++ * keyword (both may be empty but are 0 terminated) then the text, which may
++ * be empty.
++ */
++ else if (prefix_length + 5 > length)
++ errmsg = "truncated";
++
++ else if (buffer[prefix_length+1] == 0 ||
++ (buffer[prefix_length+1] == 1 &&
++ buffer[prefix_length+2] == PNG_COMPRESSION_TYPE_BASE))
+ {
+- png_warning(png_ptr, "No memory to process iTXt chunk");
+- return;
++ int compressed = buffer[prefix_length+1] != 0;
++ png_uint_32 language_offset, translated_keyword_offset;
++ png_alloc_size_t uncompressed_length = 0;
++
++ /* Now the language tag */
++ prefix_length += 3;
++ language_offset = prefix_length;
++
++ for (; prefix_length < length && buffer[prefix_length] != 0;
++ ++prefix_length)
++ /* Empty loop */ ;
++
++ /* WARNING: the length may be invalid here, this is checked below. */
++ translated_keyword_offset = ++prefix_length;
++
++ for (; prefix_length < length && buffer[prefix_length] != 0;
++ ++prefix_length)
++ /* Empty loop */ ;
++
++ /* prefix_length should now be at the trailing '\0' of the translated
++ * keyword, but it may already be over the end. None of this arithmetic
++ * can overflow because chunks are at most 2^31 bytes long, but on 16-bit
++ * systems the available allocation may overflow.
++ */
++ ++prefix_length;
++
++ if (compressed == 0 && prefix_length <= length)
++ uncompressed_length = length - prefix_length;
++
++ else if (compressed != 0 && prefix_length < length)
++ {
++ uncompressed_length = PNG_SIZE_MAX;
++
++ /* TODO: at present png_decompress_chunk imposes a single application
++ * level memory limit, this should be split to different values for
++ * iCCP and text chunks.
++ */
++ if (png_decompress_chunk(png_ptr, length, prefix_length,
++ &uncompressed_length, 1/*terminate*/) == Z_STREAM_END)
++ buffer = png_ptr->read_buffer;
++
++ else
++ errmsg = png_ptr->zstream.msg;
++ }
++
++ else
++ errmsg = "truncated";
++
++ if (errmsg == NULL)
++ {
++ png_text text;
++
++ buffer[uncompressed_length+prefix_length] = 0;
++
++ if (compressed == 0)
++ text.compression = PNG_ITXT_COMPRESSION_NONE;
++
++ else
++ text.compression = PNG_ITXT_COMPRESSION_zTXt;
++
++ text.key = (png_charp)buffer;
++ text.lang = (png_charp)buffer + language_offset;
++ text.lang_key = (png_charp)buffer + translated_keyword_offset;
++ text.text = (png_charp)buffer + prefix_length;
++ text.text_length = 0;
++ text.itxt_length = uncompressed_length;
++
++ if (png_set_text_2(png_ptr, info_ptr, &text, 1) != 0)
++ errmsg = "insufficient memory";
++ }
+ }
+
+- slength = (png_size_t)length;
+- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);
+-
+- if (png_crc_finish(png_ptr, 0))
+- {
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- png_ptr->chunkdata[slength] = 0x00;
+-
+- for (lang = png_ptr->chunkdata; *lang; lang++)
+- /* Empty loop */ ;
+-
+- lang++; /* Skip NUL separator */
+-
+- /* iTXt must have a language tag (possibly empty), two compression bytes,
+- * translated keyword (possibly empty), and possibly some text after the
+- * keyword
+- */
+-
+- if (lang >= png_ptr->chunkdata + slength - 3)
+- {
+- png_warning(png_ptr, "Truncated iTXt chunk");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+ else
+- {
+- comp_flag = *lang++;
+- comp_type = *lang++;
+- }
+-
+- for (lang_key = lang; *lang_key; lang_key++)
+- /* Empty loop */ ;
+-
+- lang_key++; /* Skip NUL separator */
+-
+- if (lang_key >= png_ptr->chunkdata + slength)
+- {
+- png_warning(png_ptr, "Truncated iTXt chunk");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- for (text = lang_key; *text; text++)
+- /* Empty loop */ ;
+-
+- text++; /* Skip NUL separator */
+-
+- if (text >= png_ptr->chunkdata + slength)
+- {
+- png_warning(png_ptr, "Malformed iTXt chunk");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- prefix_len = text - png_ptr->chunkdata;
+-
+- key=png_ptr->chunkdata;
+-
+- if (comp_flag)
+- png_decompress_chunk(png_ptr, comp_type,
+- (size_t)length, prefix_len, &data_len);
+-
+- else
+- data_len = png_strlen(png_ptr->chunkdata + prefix_len);
+-
+- text_ptr = (png_textp)png_malloc_warn(png_ptr,
+- png_sizeof(png_text));
+-
+- if (text_ptr == NULL)
+- {
+- png_warning(png_ptr, "Not enough memory to process iTXt chunk");
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+- return;
+- }
+-
+- text_ptr->compression = (int)comp_flag + 1;
+- text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);
+- text_ptr->lang = png_ptr->chunkdata + (lang - key);
+- text_ptr->itxt_length = data_len;
+- text_ptr->text_length = 0;
+- text_ptr->key = png_ptr->chunkdata;
+- text_ptr->text = png_ptr->chunkdata + prefix_len;
+-
+- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
+-
+- png_free(png_ptr, text_ptr);
+- png_free(png_ptr, png_ptr->chunkdata);
+- png_ptr->chunkdata = NULL;
+-
+- if (ret)
+- png_error(png_ptr, "Insufficient memory to store iTXt chunk");
++ errmsg = "bad compression info";
++
++ if (errmsg != NULL)
++ png_chunk_benign_error(png_ptr, errmsg);
+ }
+ #endif
+
+-/* This function is called when we haven't found a handler for a
+- * chunk. If there isn't a problem with the chunk itself (ie bad
+- * chunk name, CRC, or a critical chunk), the chunk is silently ignored
+- * -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which
+- * case it will be saved away to be written out later.
+- */
+-void /* PRIVATE */
+-png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
++#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
++/* Utility function for png_handle_unknown; set up png_ptr::unknown_chunk */
++static int
++png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length)
+ {
+- png_uint_32 skip = 0;
+-
+- png_debug(1, "in png_handle_unknown");
+-
+-#ifdef PNG_USER_LIMITS_SUPPORTED
+- if (png_ptr->user_chunk_cache_max != 0)
++ png_alloc_size_t limit = PNG_SIZE_MAX;
++
++ if (png_ptr->unknown_chunk.data != NULL)
+ {
+- if (png_ptr->user_chunk_cache_max == 1)
+- {
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+-
+- if (--png_ptr->user_chunk_cache_max == 1)
+- {
+- png_warning(png_ptr, "No space in chunk cache for unknown chunk");
+- png_crc_finish(png_ptr, length);
+- return;
+- }
+- }
+-#endif
+-
+- if (png_ptr->mode & PNG_HAVE_IDAT)
+- {
+- PNG_IDAT;
+-
+- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */
+- png_ptr->mode |= PNG_AFTER_IDAT;
+- }
+-
+- if (!(png_ptr->chunk_name[0] & 0x20))
+- {
+-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+- PNG_HANDLE_CHUNK_ALWAYS
+-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+- && png_ptr->read_user_chunk_fn == NULL
+-#endif
+- )
+-#endif
+- png_chunk_error(png_ptr, "unknown critical chunk");
+- }
+-
+-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+- if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
+-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+- || (png_ptr->read_user_chunk_fn != NULL)
+-#endif
+- )
+- {
+-#ifdef PNG_MAX_MALLOC_64K
+- if (length > (png_uint_32)65535L)
+- {
+- png_warning(png_ptr, "unknown chunk too large to fit in memory");
+- skip = length - (png_uint_32)65535L;
+- length = (png_uint_32)65535L;
+- }
+-#endif
+-
+- png_memcpy((png_charp)png_ptr->unknown_chunk.name,
+- (png_charp)png_ptr->chunk_name,
+- png_sizeof(png_ptr->unknown_chunk.name));
+-
+- png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]
+- = '\0';
+-
+- png_ptr->unknown_chunk.size = (png_size_t)length;
+-
+- if (length == 0)
+- png_ptr->unknown_chunk.data = NULL;
+-
+- else
+- {
+- png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
+- png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
+- }
+-
+-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+- if (png_ptr->read_user_chunk_fn != NULL)
+- {
+- /* Callback to user unknown chunk handler */
+- int ret;
+-
+- ret = (*(png_ptr->read_user_chunk_fn))
+- (png_ptr, &png_ptr->unknown_chunk);
+-
+- if (ret < 0)
+- png_chunk_error(png_ptr, "error in user chunk");
+-
+- if (ret == 0)
+- {
+- if (!(png_ptr->chunk_name[0] & 0x20))
+- {
+-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
+- PNG_HANDLE_CHUNK_ALWAYS)
+-#endif
+- png_chunk_error(png_ptr, "unknown critical chunk");
+- }
+-
+- png_set_unknown_chunks(png_ptr, info_ptr,
+- &png_ptr->unknown_chunk, 1);
+- }
+- }
+-
+- else
+-#endif
+- png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
+-
+ png_free(png_ptr, png_ptr->unknown_chunk.data);
+ png_ptr->unknown_chunk.data = NULL;
+ }
+
++# ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED
++ if (png_ptr->user_chunk_malloc_max > 0 &&
++ png_ptr->user_chunk_malloc_max < limit)
++ limit = png_ptr->user_chunk_malloc_max;
++
++# elif PNG_USER_CHUNK_MALLOC_MAX > 0
++ if (PNG_USER_CHUNK_MALLOC_MAX < limit)
++ limit = PNG_USER_CHUNK_MALLOC_MAX;
++# endif
++
++ if (length <= limit)
++ {
++ PNG_CSTRING_FROM_CHUNK(png_ptr->unknown_chunk.name, png_ptr->chunk_name);
++ /* The following is safe because of the PNG_SIZE_MAX init above */
++ png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/;
++ /* 'mode' is a flag array, only the bottom four bits matter here */
++ png_ptr->unknown_chunk.location = (png_byte)png_ptr->mode/*SAFE*/;
++
++ if (length == 0)
++ png_ptr->unknown_chunk.data = NULL;
++
++ else
++ {
++ /* Do a 'warn' here - it is handled below. */
++ png_ptr->unknown_chunk.data = png_voidcast(png_bytep,
++ png_malloc_warn(png_ptr, length));
++ }
++ }
++
++ if (png_ptr->unknown_chunk.data == NULL && length > 0)
++ {
++ /* This is benign because we clean up correctly */
++ png_crc_finish(png_ptr, length);
++ png_chunk_benign_error(png_ptr, "unknown chunk exceeds memory limits");
++ return 0;
++ }
++
+ else
+-#endif
+- skip = length;
+-
+- png_crc_finish(png_ptr, skip);
+-
+-#ifndef PNG_READ_USER_CHUNKS_SUPPORTED
+- PNG_UNUSED(info_ptr) /* Quiet compiler warnings about unused info_ptr */
+-#endif
++ {
++ if (length > 0)
++ png_crc_read(png_ptr, png_ptr->unknown_chunk.data, length);
++ png_crc_finish(png_ptr, 0);
++ return 1;
++ }
++}
++#endif /* READ_UNKNOWN_CHUNKS */
++
++/* Handle an unknown, or known but disabled, chunk */
++void /* PRIVATE */
++png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
++ png_uint_32 length, int keep)
++{
++ int handled = 0; /* the chunk was handled */
++
++ png_debug(1, "in png_handle_unknown");
++
++#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
++ /* NOTE: this code is based on the code in libpng-1.4.12 except for fixing
++ * the bug which meant that setting a non-default behavior for a specific
++ * chunk would be ignored (the default was always used unless a user
++ * callback was installed).
++ *
++ * 'keep' is the value from the png_chunk_unknown_handling, the setting for
++ * this specific chunk_name, if PNG_HANDLE_AS_UNKNOWN_SUPPORTED, if not it
++ * will always be PNG_HANDLE_CHUNK_AS_DEFAULT and it needs to be set here.
++ * This is just an optimization to avoid multiple calls to the lookup
++ * function.
++ */
++# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++# ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++ keep = png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name);
++# endif
++# endif
++
++ /* One of the following methods will read the chunk or skip it (at least one
++ * of these is always defined because this is the only way to switch on
++ * PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
++ */
++# ifdef PNG_READ_USER_CHUNKS_SUPPORTED
++ /* The user callback takes precedence over the chunk keep value, but the
++ * keep value is still required to validate a save of a critical chunk.
++ */
++ if (png_ptr->read_user_chunk_fn != NULL)
++ {
++ if (png_cache_unknown_chunk(png_ptr, length) != 0)
++ {
++ /* Callback to user unknown chunk handler */
++ int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr,
++ &png_ptr->unknown_chunk);
++
++ /* ret is:
++ * negative: An error occured, png_chunk_error will be called.
++ * zero: The chunk was not handled, the chunk will be discarded
++ * unless png_set_keep_unknown_chunks has been used to set
++ * a 'keep' behavior for this particular chunk, in which
++ * case that will be used. A critical chunk will cause an
++ * error at this point unless it is to be saved.
++ * positive: The chunk was handled, libpng will ignore/discard it.
++ */
++ if (ret < 0)
++ png_chunk_error(png_ptr, "error in user chunk");
++
++ else if (ret == 0)
++ {
++ /* If the keep value is 'default' or 'never' override it, but
++ * still error out on critical chunks unless the keep value is
++ * 'always' While this is weird it is the behavior in 1.4.12.
++ * A possible improvement would be to obey the value set for the
++ * chunk, but this would be an API change that would probably
++ * damage some applications.
++ *
++ * The png_app_warning below catches the case that matters, where
++ * the application has not set specific save or ignore for this
++ * chunk or global save or ignore.
++ */
++ if (keep < PNG_HANDLE_CHUNK_IF_SAFE)
++ {
++# ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++ if (png_ptr->unknown_default < PNG_HANDLE_CHUNK_IF_SAFE)
++ {
++ png_chunk_warning(png_ptr, "Saving unknown chunk:");
++ png_app_warning(png_ptr,
++ "forcing save of an unhandled chunk;"
++ " please call png_set_keep_unknown_chunks");
++ /* with keep = PNG_HANDLE_CHUNK_IF_SAFE */
++ }
++# endif
++ keep = PNG_HANDLE_CHUNK_IF_SAFE;
++ }
++ }
++
++ else /* chunk was handled */
++ {
++ handled = 1;
++ /* Critical chunks can be safely discarded at this point. */
++ keep = PNG_HANDLE_CHUNK_NEVER;
++ }
++ }
++
++ else
++ keep = PNG_HANDLE_CHUNK_NEVER; /* insufficient memory */
++ }
++
++ else
++ /* Use the SAVE_UNKNOWN_CHUNKS code or skip the chunk */
++# endif /* READ_USER_CHUNKS */
++
++# ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
++ {
++ /* keep is currently just the per-chunk setting, if there was no
++ * setting change it to the global default now (not that this may
++ * still be AS_DEFAULT) then obtain the cache of the chunk if required,
++ * if not simply skip the chunk.
++ */
++ if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
++ keep = png_ptr->unknown_default;
++
++ if (keep == PNG_HANDLE_CHUNK_ALWAYS ||
++ (keep == PNG_HANDLE_CHUNK_IF_SAFE &&
++ PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
++ {
++ if (png_cache_unknown_chunk(png_ptr, length) == 0)
++ keep = PNG_HANDLE_CHUNK_NEVER;
++ }
++
++ else
++ png_crc_finish(png_ptr, length);
++ }
++# else
++# ifndef PNG_READ_USER_CHUNKS_SUPPORTED
++# error no method to support READ_UNKNOWN_CHUNKS
++# endif
++
++ {
++ /* If here there is no read callback pointer set and no support is
++ * compiled in to just save the unknown chunks, so simply skip this
++ * chunk. If 'keep' is something other than AS_DEFAULT or NEVER then
++ * the app has erroneously asked for unknown chunk saving when there
++ * is no support.
++ */
++ if (keep > PNG_HANDLE_CHUNK_NEVER)
++ png_app_error(png_ptr, "no unknown chunk support available");
++
++ png_crc_finish(png_ptr, length);
++ }
++# endif
++
++# ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
++ /* Now store the chunk in the chunk list if appropriate, and if the limits
++ * permit it.
++ */
++ if (keep == PNG_HANDLE_CHUNK_ALWAYS ||
++ (keep == PNG_HANDLE_CHUNK_IF_SAFE &&
++ PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
++ {
++# ifdef PNG_USER_LIMITS_SUPPORTED
++ switch (png_ptr->user_chunk_cache_max)
++ {
++ case 2:
++ png_ptr->user_chunk_cache_max = 1;
++ png_chunk_benign_error(png_ptr, "no space in chunk cache");
++ /* FALL THROUGH */
++ case 1:
++ /* NOTE: prior to 1.6.0 this case resulted in an unknown critical
++ * chunk being skipped, now there will be a hard error below.
++ */
++ break;
++
++ default: /* not at limit */
++ --(png_ptr->user_chunk_cache_max);
++ /* FALL THROUGH */
++ case 0: /* no limit */
++# endif /* USER_LIMITS */
++ /* Here when the limit isn't reached or when limits are compiled
++ * out; store the chunk.
++ */
++ png_set_unknown_chunks(png_ptr, info_ptr,
++ &png_ptr->unknown_chunk, 1);
++ handled = 1;
++# ifdef PNG_USER_LIMITS_SUPPORTED
++ break;
++ }
++# endif
++ }
++# else /* no store support: the chunk must be handled by the user callback */
++ PNG_UNUSED(info_ptr)
++# endif
++
++ /* Regardless of the error handling below the cached data (if any) can be
++ * freed now. Notice that the data is not freed if there is a png_error, but
++ * it will be freed by destroy_read_struct.
++ */
++ if (png_ptr->unknown_chunk.data != NULL)
++ png_free(png_ptr, png_ptr->unknown_chunk.data);
++ png_ptr->unknown_chunk.data = NULL;
++
++#else /* !PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */
++ /* There is no support to read an unknown chunk, so just skip it. */
++ png_crc_finish(png_ptr, length);
++ PNG_UNUSED(info_ptr)
++ PNG_UNUSED(keep)
++#endif /* !READ_UNKNOWN_CHUNKS */
++
++ /* Check for unhandled critical chunks */
++ if (handled == 0 && PNG_CHUNK_CRITICAL(png_ptr->chunk_name))
++ png_chunk_error(png_ptr, "unhandled critical chunk");
+ }
+
+ /* This function is called to verify that a chunk name is valid.
+@@ -2682,267 +2996,527 @@
+ * the chunk name itself is valid.
+ */
+
+-#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
++/* Bit hacking: the test for an invalid byte in the 4 byte chunk name is:
++ *
++ * ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
++ */
+
+ void /* PRIVATE */
+-png_check_chunk_name(png_structp png_ptr, png_const_bytep chunk_name)
++png_check_chunk_name(png_structrp png_ptr, png_uint_32 chunk_name)
+ {
++ int i;
++
+ png_debug(1, "in png_check_chunk_name");
+- if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||
+- isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))
++
++ for (i=1; i<=4; ++i)
+ {
+- png_chunk_error(png_ptr, "invalid chunk type");
++ int c = chunk_name & 0xff;
++
++ if (c < 65 || c > 122 || (c > 90 && c < 97))
++ png_chunk_error(png_ptr, "invalid chunk type");
++
++ chunk_name >>= 8;
+ }
+ }
+
+-/* Combines the row recently read in with the existing pixels in the
+- * row. This routine takes care of alpha and transparency if requested.
+- * This routine also handles the two methods of progressive display
+- * of interlaced images, depending on the mask value.
+- * The mask value describes which pixels are to be combined with
+- * the row. The pattern always repeats every 8 pixels, so just 8
+- * bits are needed. A one indicates the pixel is to be combined,
+- * a zero indicates the pixel is to be skipped. This is in addition
+- * to any alpha or transparency value associated with the pixel. If
+- * you want all pixels to be combined, pass 0xff (255) in mask.
++/* Combines the row recently read in with the existing pixels in the row. This
++ * routine takes care of alpha and transparency if requested. This routine also
++ * handles the two methods of progressive display of interlaced images,
++ * depending on the 'display' value; if 'display' is true then the whole row
++ * (dp) is filled from the start by replicating the available pixels. If
++ * 'display' is false only those pixels present in the pass are filled in.
+ */
+-
+ void /* PRIVATE */
+-png_combine_row(png_structp png_ptr, png_bytep row, int mask)
++png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
+ {
++ unsigned int pixel_depth = png_ptr->transformed_pixel_depth;
++ png_const_bytep sp = png_ptr->row_buf + 1;
++ png_alloc_size_t row_width = png_ptr->width;
++ unsigned int pass = png_ptr->pass;
++ png_bytep end_ptr = 0;
++ png_byte end_byte = 0;
++ unsigned int end_mask;
++
+ png_debug(1, "in png_combine_row");
+
+- /* Added in 1.5.4: the row_info should match the information returned by any
+- * call to png_read_update_info at this point. Do not continue if we got
++ /* Added in 1.5.6: it should not be possible to enter this routine until at
++ * least one row has been read from the PNG data and transformed.
++ */
++ if (pixel_depth == 0)
++ png_error(png_ptr, "internal row logic error");
++
++ /* Added in 1.5.4: the pixel depth should match the information returned by
++ * any call to png_read_update_info at this point. Do not continue if we got
+ * this wrong.
+ */
+ if (png_ptr->info_rowbytes != 0 && png_ptr->info_rowbytes !=
+- PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width))
++ PNG_ROWBYTES(pixel_depth, row_width))
+ png_error(png_ptr, "internal row size calculation error");
+
+- if (mask == 0xff)
++ /* Don't expect this to ever happen: */
++ if (row_width == 0)
++ png_error(png_ptr, "internal row width error");
++
++ /* Preserve the last byte in cases where only part of it will be overwritten,
++ * the multiply below may overflow, we don't care because ANSI-C guarantees
++ * we get the low bits.
++ */
++ end_mask = (pixel_depth * row_width) & 7;
++ if (end_mask != 0)
+ {
+- png_memcpy(row, png_ptr->row_buf + 1,
+- PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));
++ /* end_ptr == NULL is a flag to say do nothing */
++ end_ptr = dp + PNG_ROWBYTES(pixel_depth, row_width) - 1;
++ end_byte = *end_ptr;
++# ifdef PNG_READ_PACKSWAP_SUPPORTED
++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
++ /* little-endian byte */
++ end_mask = 0xff << end_mask;
++
++ else /* big-endian byte */
++# endif
++ end_mask = 0xff >> end_mask;
++ /* end_mask is now the bits to *keep* from the destination row */
+ }
+
+- else
++ /* For non-interlaced images this reduces to a memcpy(). A memcpy()
++ * will also happen if interlacing isn't supported or if the application
++ * does not call png_set_interlace_handling(). In the latter cases the
++ * caller just gets a sequence of the unexpanded rows from each interlace
++ * pass.
++ */
++#ifdef PNG_READ_INTERLACING_SUPPORTED
++ if (png_ptr->interlaced != 0 &&
++ (png_ptr->transformations & PNG_INTERLACE) != 0 &&
++ pass < 6 && (display == 0 ||
++ /* The following copies everything for 'display' on passes 0, 2 and 4. */
++ (display == 1 && (pass & 1) != 0)))
+ {
+- switch (png_ptr->row_info.pixel_depth)
++ /* Narrow images may have no bits in a pass; the caller should handle
++ * this, but this test is cheap:
++ */
++ if (row_width <= PNG_PASS_START_COL(pass))
++ return;
++
++ if (pixel_depth < 8)
+ {
+- case 1:
++ /* For pixel depths up to 4 bpp the 8-pixel mask can be expanded to fit
++ * into 32 bits, then a single loop over the bytes using the four byte
++ * values in the 32-bit mask can be used. For the 'display' option the
++ * expanded mask may also not require any masking within a byte. To
++ * make this work the PACKSWAP option must be taken into account - it
++ * simply requires the pixels to be reversed in each byte.
++ *
++ * The 'regular' case requires a mask for each of the first 6 passes,
++ * the 'display' case does a copy for the even passes in the range
++ * 0..6. This has already been handled in the test above.
++ *
++ * The masks are arranged as four bytes with the first byte to use in
++ * the lowest bits (little-endian) regardless of the order (PACKSWAP or
++ * not) of the pixels in each byte.
++ *
++ * NOTE: the whole of this logic depends on the caller of this function
++ * only calling it on rows appropriate to the pass. This function only
++ * understands the 'x' logic; the 'y' logic is handled by the caller.
++ *
++ * The following defines allow generation of compile time constant bit
++ * masks for each pixel depth and each possibility of swapped or not
++ * swapped bytes. Pass 'p' is in the range 0..6; 'x', a pixel index,
++ * is in the range 0..7; and the result is 1 if the pixel is to be
++ * copied in the pass, 0 if not. 'S' is for the sparkle method, 'B'
++ * for the block method.
++ *
++ * With some compilers a compile time expression of the general form:
++ *
++ * (shift >= 32) ? (a >> (shift-32)) : (b >> shift)
++ *
++ * Produces warnings with values of 'shift' in the range 33 to 63
++ * because the right hand side of the ?: expression is evaluated by
++ * the compiler even though it isn't used. Microsoft Visual C (various
++ * versions) and the Intel C compiler are known to do this. To avoid
++ * this the following macros are used in 1.5.6. This is a temporary
++ * solution to avoid destabilizing the code during the release process.
++ */
++# if PNG_USE_COMPILE_TIME_MASKS
++# define PNG_LSR(x,s) ((x)>>((s) & 0x1f))
++# define PNG_LSL(x,s) ((x)<<((s) & 0x1f))
++# else
++# define PNG_LSR(x,s) ((x)>>(s))
++# define PNG_LSL(x,s) ((x)<<(s))
++# endif
++# define S_COPY(p,x) (((p)<4 ? PNG_LSR(0x80088822,(3-(p))*8+(7-(x))) :\
++ PNG_LSR(0xaa55ff00,(7-(p))*8+(7-(x)))) & 1)
++# define B_COPY(p,x) (((p)<4 ? PNG_LSR(0xff0fff33,(3-(p))*8+(7-(x))) :\
++ PNG_LSR(0xff55ff00,(7-(p))*8+(7-(x)))) & 1)
++
++ /* Return a mask for pass 'p' pixel 'x' at depth 'd'. The mask is
++ * little endian - the first pixel is at bit 0 - however the extra
++ * parameter 's' can be set to cause the mask position to be swapped
++ * within each byte, to match the PNG format. This is done by XOR of
++ * the shift with 7, 6 or 4 for bit depths 1, 2 and 4.
++ */
++# define PIXEL_MASK(p,x,d,s) \
++ (PNG_LSL(((PNG_LSL(1U,(d)))-1),(((x)*(d))^((s)?8-(d):0))))
++
++ /* Hence generate the appropriate 'block' or 'sparkle' pixel copy mask.
++ */
++# define S_MASKx(p,x,d,s) (S_COPY(p,x)?PIXEL_MASK(p,x,d,s):0)
++# define B_MASKx(p,x,d,s) (B_COPY(p,x)?PIXEL_MASK(p,x,d,s):0)
++
++ /* Combine 8 of these to get the full mask. For the 1-bpp and 2-bpp
++ * cases the result needs replicating, for the 4-bpp case the above
++ * generates a full 32 bits.
++ */
++# define MASK_EXPAND(m,d) ((m)*((d)==1?0x01010101:((d)==2?0x00010001:1)))
++
++# define S_MASK(p,d,s) MASK_EXPAND(S_MASKx(p,0,d,s) + S_MASKx(p,1,d,s) +\
++ S_MASKx(p,2,d,s) + S_MASKx(p,3,d,s) + S_MASKx(p,4,d,s) +\
++ S_MASKx(p,5,d,s) + S_MASKx(p,6,d,s) + S_MASKx(p,7,d,s), d)
++
++# define B_MASK(p,d,s) MASK_EXPAND(B_MASKx(p,0,d,s) + B_MASKx(p,1,d,s) +\
++ B_MASKx(p,2,d,s) + B_MASKx(p,3,d,s) + B_MASKx(p,4,d,s) +\
++ B_MASKx(p,5,d,s) + B_MASKx(p,6,d,s) + B_MASKx(p,7,d,s), d)
++
++#if PNG_USE_COMPILE_TIME_MASKS
++ /* Utility macros to construct all the masks for a depth/swap
++ * combination. The 's' parameter says whether the format is PNG
++ * (big endian bytes) or not. Only the three odd-numbered passes are
++ * required for the display/block algorithm.
++ */
++# define S_MASKS(d,s) { S_MASK(0,d,s), S_MASK(1,d,s), S_MASK(2,d,s),\
++ S_MASK(3,d,s), S_MASK(4,d,s), S_MASK(5,d,s) }
++
++# define B_MASKS(d,s) { B_MASK(1,d,s), B_MASK(3,d,s), B_MASK(5,d,s) }
++
++# define DEPTH_INDEX(d) ((d)==1?0:((d)==2?1:2))
++
++ /* Hence the pre-compiled masks indexed by PACKSWAP (or not), depth and
++ * then pass:
++ */
++ static PNG_CONST png_uint_32 row_mask[2/*PACKSWAP*/][3/*depth*/][6] =
+ {
+- png_bytep sp = png_ptr->row_buf + 1;
+- png_bytep dp = row;
+- int s_inc, s_start, s_end;
+- int m = 0x80;
+- int shift;
+- png_uint_32 i;
+- png_uint_32 row_width = png_ptr->width;
+-
+-#ifdef PNG_READ_PACKSWAP_SUPPORTED
+- if (png_ptr->transformations & PNG_PACKSWAP)
++ /* Little-endian byte masks for PACKSWAP */
++ { S_MASKS(1,0), S_MASKS(2,0), S_MASKS(4,0) },
++ /* Normal (big-endian byte) masks - PNG format */
++ { S_MASKS(1,1), S_MASKS(2,1), S_MASKS(4,1) }
++ };
++
++ /* display_mask has only three entries for the odd passes, so index by
++ * pass>>1.
++ */
++ static PNG_CONST png_uint_32 display_mask[2][3][3] =
++ {
++ /* Little-endian byte masks for PACKSWAP */
++ { B_MASKS(1,0), B_MASKS(2,0), B_MASKS(4,0) },
++ /* Normal (big-endian byte) masks - PNG format */
++ { B_MASKS(1,1), B_MASKS(2,1), B_MASKS(4,1) }
++ };
++
++# define MASK(pass,depth,display,png)\
++ ((display)?display_mask[png][DEPTH_INDEX(depth)][pass>>1]:\
++ row_mask[png][DEPTH_INDEX(depth)][pass])
++
++#else /* !PNG_USE_COMPILE_TIME_MASKS */
++ /* This is the runtime alternative: it seems unlikely that this will
++ * ever be either smaller or faster than the compile time approach.
++ */
++# define MASK(pass,depth,display,png)\
++ ((display)?B_MASK(pass,depth,png):S_MASK(pass,depth,png))
++#endif /* !USE_COMPILE_TIME_MASKS */
++
++ /* Use the appropriate mask to copy the required bits. In some cases
++ * the byte mask will be 0 or 0xff; optimize these cases. row_width is
++ * the number of pixels, but the code copies bytes, so it is necessary
++ * to special case the end.
++ */
++ png_uint_32 pixels_per_byte = 8 / pixel_depth;
++ png_uint_32 mask;
++
++# ifdef PNG_READ_PACKSWAP_SUPPORTED
++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
++ mask = MASK(pass, pixel_depth, display, 0);
++
++ else
++# endif
++ mask = MASK(pass, pixel_depth, display, 1);
++
++ for (;;)
++ {
++ png_uint_32 m;
++
++ /* It doesn't matter in the following if png_uint_32 has more than
++ * 32 bits because the high bits always match those in m<<24; it is,
++ * however, essential to use OR here, not +, because of this.
++ */
++ m = mask;
++ mask = (m >> 8) | (m << 24); /* rotate right to good compilers */
++ m &= 0xff;
++
++ if (m != 0) /* something to copy */
+ {
+- s_start = 0;
+- s_end = 7;
+- s_inc = 1;
++ if (m != 0xff)
++ *dp = (png_byte)((*dp & ~m) | (*sp & m));
++ else
++ *dp = *sp;
+ }
+
+- else
+-#endif
+- {
+- s_start = 7;
+- s_end = 0;
+- s_inc = -1;
+- }
+-
+- shift = s_start;
+-
+- for (i = 0; i < row_width; i++)
+- {
+- if (m & mask)
+- {
+- int value;
+-
+- value = (*sp >> shift) & 0x01;
+- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
+- *dp |= (png_byte)(value << shift);
+- }
+-
+- if (shift == s_end)
+- {
+- shift = s_start;
+- sp++;
+- dp++;
+- }
+-
+- else
+- shift += s_inc;
+-
+- if (m == 1)
+- m = 0x80;
+-
+- else
+- m >>= 1;
+- }
+- break;
+- }
+-
+- case 2:
+- {
+- png_bytep sp = png_ptr->row_buf + 1;
+- png_bytep dp = row;
+- int s_start, s_end, s_inc;
+- int m = 0x80;
+- int shift;
+- png_uint_32 i;
+- png_uint_32 row_width = png_ptr->width;
+- int value;
+-
+-#ifdef PNG_READ_PACKSWAP_SUPPORTED
+- if (png_ptr->transformations & PNG_PACKSWAP)
+- {
+- s_start = 0;
+- s_end = 6;
+- s_inc = 2;
+- }
+-
+- else
+-#endif
+- {
+- s_start = 6;
+- s_end = 0;
+- s_inc = -2;
+- }
+-
+- shift = s_start;
+-
+- for (i = 0; i < row_width; i++)
+- {
+- if (m & mask)
+- {
+- value = (*sp >> shift) & 0x03;
+- *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
+- *dp |= (png_byte)(value << shift);
+- }
+-
+- if (shift == s_end)
+- {
+- shift = s_start;
+- sp++;
+- dp++;
+- }
+-
+- else
+- shift += s_inc;
+-
+- if (m == 1)
+- m = 0x80;
+-
+- else
+- m >>= 1;
+- }
+- break;
+- }
+-
+- case 4:
+- {
+- png_bytep sp = png_ptr->row_buf + 1;
+- png_bytep dp = row;
+- int s_start, s_end, s_inc;
+- int m = 0x80;
+- int shift;
+- png_uint_32 i;
+- png_uint_32 row_width = png_ptr->width;
+- int value;
+-
+-#ifdef PNG_READ_PACKSWAP_SUPPORTED
+- if (png_ptr->transformations & PNG_PACKSWAP)
+- {
+- s_start = 0;
+- s_end = 4;
+- s_inc = 4;
+- }
+-
+- else
+-#endif
+- {
+- s_start = 4;
+- s_end = 0;
+- s_inc = -4;
+- }
+- shift = s_start;
+-
+- for (i = 0; i < row_width; i++)
+- {
+- if (m & mask)
+- {
+- value = (*sp >> shift) & 0xf;
+- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
+- *dp |= (png_byte)(value << shift);
+- }
+-
+- if (shift == s_end)
+- {
+- shift = s_start;
+- sp++;
+- dp++;
+- }
+-
+- else
+- shift += s_inc;
+-
+- if (m == 1)
+- m = 0x80;
+-
+- else
+- m >>= 1;
+- }
+- break;
+- }
+-
+- default:
+- {
+- png_bytep sp = png_ptr->row_buf + 1;
+- png_bytep dp = row;
+- png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
+- png_uint_32 i;
+- png_uint_32 row_width = png_ptr->width;
+- png_byte m = 0x80;
+-
+- for (i = 0; i < row_width; i++)
+- {
+- if (m & mask)
+- {
+- png_memcpy(dp, sp, pixel_bytes);
+- }
+-
+- sp += pixel_bytes;
+- dp += pixel_bytes;
+-
+- if (m == 1)
+- m = 0x80;
+-
+- else
+- m >>= 1;
+- }
+- break;
++ /* NOTE: this may overwrite the last byte with garbage if the image
++ * is not an exact number of bytes wide; libpng has always done
++ * this.
++ */
++ if (row_width <= pixels_per_byte)
++ break; /* May need to restore part of the last byte */
++
++ row_width -= pixels_per_byte;
++ ++dp;
++ ++sp;
+ }
+ }
++
++ else /* pixel_depth >= 8 */
++ {
++ unsigned int bytes_to_copy, bytes_to_jump;
++
++ /* Validate the depth - it must be a multiple of 8 */
++ if (pixel_depth & 7)
++ png_error(png_ptr, "invalid user transform pixel depth");
++
++ pixel_depth >>= 3; /* now in bytes */
++ row_width *= pixel_depth;
++
++ /* Regardless of pass number the Adam 7 interlace always results in a
++ * fixed number of pixels to copy then to skip. There may be a
++ * different number of pixels to skip at the start though.
++ */
++ {
++ unsigned int offset = PNG_PASS_START_COL(pass) * pixel_depth;
++
++ row_width -= offset;
++ dp += offset;
++ sp += offset;
++ }
++
++ /* Work out the bytes to copy. */
++ if (display != 0)
++ {
++ /* When doing the 'block' algorithm the pixel in the pass gets
++ * replicated to adjacent pixels. This is why the even (0,2,4,6)
++ * passes are skipped above - the entire expanded row is copied.
++ */
++ bytes_to_copy = (1<<((6-pass)>>1)) * pixel_depth;
++
++ /* But don't allow this number to exceed the actual row width. */
++ if (bytes_to_copy > row_width)
++ bytes_to_copy = (unsigned int)/*SAFE*/row_width;
++ }
++
++ else /* normal row; Adam7 only ever gives us one pixel to copy. */
++ bytes_to_copy = pixel_depth;
++
++ /* In Adam7 there is a constant offset between where the pixels go. */
++ bytes_to_jump = PNG_PASS_COL_OFFSET(pass) * pixel_depth;
++
++ /* And simply copy these bytes. Some optimization is possible here,
++ * depending on the value of 'bytes_to_copy'. Special case the low
++ * byte counts, which we know to be frequent.
++ *
++ * Notice that these cases all 'return' rather than 'break' - this
++ * avoids an unnecessary test on whether to restore the last byte
++ * below.
++ */
++ switch (bytes_to_copy)
++ {
++ case 1:
++ for (;;)
++ {
++ *dp = *sp;
++
++ if (row_width <= bytes_to_jump)
++ return;
++
++ dp += bytes_to_jump;
++ sp += bytes_to_jump;
++ row_width -= bytes_to_jump;
++ }
++
++ case 2:
++ /* There is a possibility of a partial copy at the end here; this
++ * slows the code down somewhat.
++ */
++ do
++ {
++ dp[0] = sp[0], dp[1] = sp[1];
++
++ if (row_width <= bytes_to_jump)
++ return;
++
++ sp += bytes_to_jump;
++ dp += bytes_to_jump;
++ row_width -= bytes_to_jump;
++ }
++ while (row_width > 1);
++
++ /* And there can only be one byte left at this point: */
++ *dp = *sp;
++ return;
++
++ case 3:
++ /* This can only be the RGB case, so each copy is exactly one
++ * pixel and it is not necessary to check for a partial copy.
++ */
++ for (;;)
++ {
++ dp[0] = sp[0], dp[1] = sp[1], dp[2] = sp[2];
++
++ if (row_width <= bytes_to_jump)
++ return;
++
++ sp += bytes_to_jump;
++ dp += bytes_to_jump;
++ row_width -= bytes_to_jump;
++ }
++
++ default:
++#if PNG_ALIGN_TYPE != PNG_ALIGN_NONE
++ /* Check for double byte alignment and, if possible, use a
++ * 16-bit copy. Don't attempt this for narrow images - ones that
++ * are less than an interlace panel wide. Don't attempt it for
++ * wide bytes_to_copy either - use the memcpy there.
++ */
++ if (bytes_to_copy < 16 /*else use memcpy*/ &&
++ png_isaligned(dp, png_uint_16) &&
++ png_isaligned(sp, png_uint_16) &&
++ bytes_to_copy % (sizeof (png_uint_16)) == 0 &&
++ bytes_to_jump % (sizeof (png_uint_16)) == 0)
++ {
++ /* Everything is aligned for png_uint_16 copies, but try for
++ * png_uint_32 first.
++ */
++ if (png_isaligned(dp, png_uint_32) != 0 &&
++ png_isaligned(sp, png_uint_32) != 0 &&
++ bytes_to_copy % (sizeof (png_uint_32)) == 0 &&
++ bytes_to_jump % (sizeof (png_uint_32)) == 0)
++ {
++ png_uint_32p dp32 = png_aligncast(png_uint_32p,dp);
++ png_const_uint_32p sp32 = png_aligncastconst(
++ png_const_uint_32p, sp);
++ size_t skip = (bytes_to_jump-bytes_to_copy) /
++ (sizeof (png_uint_32));
++
++ do
++ {
++ size_t c = bytes_to_copy;
++ do
++ {
++ *dp32++ = *sp32++;
++ c -= (sizeof (png_uint_32));
++ }
++ while (c > 0);
++
++ if (row_width <= bytes_to_jump)
++ return;
++
++ dp32 += skip;
++ sp32 += skip;
++ row_width -= bytes_to_jump;
++ }
++ while (bytes_to_copy <= row_width);
++
++ /* Get to here when the row_width truncates the final copy.
++ * There will be 1-3 bytes left to copy, so don't try the
++ * 16-bit loop below.
++ */
++ dp = (png_bytep)dp32;
++ sp = (png_const_bytep)sp32;
++ do
++ *dp++ = *sp++;
++ while (--row_width > 0);
++ return;
++ }
++
++ /* Else do it in 16-bit quantities, but only if the size is
++ * not too large.
++ */
++ else
++ {
++ png_uint_16p dp16 = png_aligncast(png_uint_16p, dp);
++ png_const_uint_16p sp16 = png_aligncastconst(
++ png_const_uint_16p, sp);
++ size_t skip = (bytes_to_jump-bytes_to_copy) /
++ (sizeof (png_uint_16));
++
++ do
++ {
++ size_t c = bytes_to_copy;
++ do
++ {
++ *dp16++ = *sp16++;
++ c -= (sizeof (png_uint_16));
++ }
++ while (c > 0);
++
++ if (row_width <= bytes_to_jump)
++ return;
++
++ dp16 += skip;
++ sp16 += skip;
++ row_width -= bytes_to_jump;
++ }
++ while (bytes_to_copy <= row_width);
++
++ /* End of row - 1 byte left, bytes_to_copy > row_width: */
++ dp = (png_bytep)dp16;
++ sp = (png_const_bytep)sp16;
++ do
++ *dp++ = *sp++;
++ while (--row_width > 0);
++ return;
++ }
++ }
++#endif /* ALIGN_TYPE code */
++
++ /* The true default - use a memcpy: */
++ for (;;)
++ {
++ memcpy(dp, sp, bytes_to_copy);
++
++ if (row_width <= bytes_to_jump)
++ return;
++
++ sp += bytes_to_jump;
++ dp += bytes_to_jump;
++ row_width -= bytes_to_jump;
++ if (bytes_to_copy > row_width)
++ bytes_to_copy = (unsigned int)/*SAFE*/row_width;
++ }
++ }
++
++ /* NOT REACHED*/
++ } /* pixel_depth >= 8 */
++
++ /* Here if pixel_depth < 8 to check 'end_ptr' below. */
+ }
++ else
++#endif /* READ_INTERLACING */
++
++ /* If here then the switch above wasn't used so just memcpy the whole row
++ * from the temporary row buffer (notice that this overwrites the end of the
++ * destination row if it is a partial byte.)
++ */
++ memcpy(dp, sp, PNG_ROWBYTES(pixel_depth, row_width));
++
++ /* Restore the overwritten bits from the last byte if necessary. */
++ if (end_ptr != NULL)
++ *end_ptr = (png_byte)((end_byte & end_mask) | (*end_ptr & ~end_mask));
+ }
+
+ #ifdef PNG_READ_INTERLACING_SUPPORTED
+ void /* PRIVATE */
+-png_do_read_interlace(png_structp png_ptr)
++png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
++ png_uint_32 transformations /* Because these may affect the byte layout */)
+ {
+- png_row_infop row_info = &(png_ptr->row_info);
+- png_bytep row = png_ptr->row_buf + 1;
+- int pass = png_ptr->pass;
+- png_uint_32 transformations = png_ptr->transformations;
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+ /* Offset to next interlace block */
+- PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ png_debug(1, "in png_do_read_interlace");
+ if (row != NULL && row_info != NULL)
+@@ -2965,7 +3539,7 @@
+ int j;
+
+ #ifdef PNG_READ_PACKSWAP_SUPPORTED
+- if (transformations & PNG_PACKSWAP)
++ if ((transformations & PNG_PACKSWAP) != 0)
+ {
+ sshift = (int)((row_info->width + 7) & 0x07);
+ dshift = (int)((final_width + 7) & 0x07);
+@@ -2989,8 +3563,9 @@
+ v = (png_byte)((*sp >> sshift) & 0x01);
+ for (j = 0; j < jstop; j++)
+ {
+- *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
+- *dp |= (png_byte)(v << dshift);
++ unsigned int tmp = *dp & (0x7f7f >> (7 - dshift));
++ tmp |= v << dshift;
++ *dp = (png_byte)(tmp & 0xff);
+
+ if (dshift == s_end)
+ {
+@@ -3024,7 +3599,7 @@
+ png_uint_32 i;
+
+ #ifdef PNG_READ_PACKSWAP_SUPPORTED
+- if (transformations & PNG_PACKSWAP)
++ if ((transformations & PNG_PACKSWAP) != 0)
+ {
+ sshift = (int)(((row_info->width + 3) & 0x03) << 1);
+ dshift = (int)(((final_width + 3) & 0x03) << 1);
+@@ -3051,8 +3626,9 @@
+ v = (png_byte)((*sp >> sshift) & 0x03);
+ for (j = 0; j < jstop; j++)
+ {
+- *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
+- *dp |= (png_byte)(v << dshift);
++ unsigned int tmp = *dp & (0x3f3f >> (6 - dshift));
++ tmp |= v << dshift;
++ *dp = (png_byte)(tmp & 0xff);
+
+ if (dshift == s_end)
+ {
+@@ -3086,7 +3662,7 @@
+ int jstop = png_pass_inc[pass];
+
+ #ifdef PNG_READ_PACKSWAP_SUPPORTED
+- if (transformations & PNG_PACKSWAP)
++ if ((transformations & PNG_PACKSWAP) != 0)
+ {
+ sshift = (int)(((row_info->width + 1) & 0x01) << 2);
+ dshift = (int)(((final_width + 1) & 0x01) << 2);
+@@ -3107,13 +3683,14 @@
+
+ for (i = 0; i < row_info->width; i++)
+ {
+- png_byte v = (png_byte)((*sp >> sshift) & 0xf);
++ png_byte v = (png_byte)((*sp >> sshift) & 0x0f);
+ int j;
+
+ for (j = 0; j < jstop; j++)
+ {
+- *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
+- *dp |= (png_byte)(v << dshift);
++ unsigned int tmp = *dp & (0xf0f >> (4 - dshift));
++ tmp |= v << dshift;
++ *dp = (png_byte)(tmp & 0xff);
+
+ if (dshift == s_end)
+ {
+@@ -3136,6 +3713,7 @@
+ }
+ break;
+ }
++
+ default:
+ {
+ png_size_t pixel_bytes = (row_info->pixel_depth >> 3);
+@@ -3150,14 +3728,14 @@
+
+ for (i = 0; i < row_info->width; i++)
+ {
+- png_byte v[8];
++ png_byte v[8]; /* SAFE; pixel_depth does not exceed 64 */
+ int j;
+
+- png_memcpy(v, sp, pixel_bytes);
++ memcpy(v, sp, pixel_bytes);
+
+ for (j = 0; j < jstop; j++)
+ {
+- png_memcpy(dp, v, pixel_bytes);
++ memcpy(dp, v, pixel_bytes);
+ dp -= pixel_bytes;
+ }
+
+@@ -3166,6 +3744,7 @@
+ break;
+ }
+ }
++
+ row_info->width = final_width;
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);
+ }
+@@ -3173,167 +3752,427 @@
+ PNG_UNUSED(transformations) /* Silence compiler warning */
+ #endif
+ }
+-#endif /* PNG_READ_INTERLACING_SUPPORTED */
++#endif /* READ_INTERLACING */
++
++static void
++png_read_filter_row_sub(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ png_size_t i;
++ png_size_t istop = row_info->rowbytes;
++ unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
++ png_bytep rp = row + bpp;
++
++ PNG_UNUSED(prev_row)
++
++ for (i = bpp; i < istop; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
++ rp++;
++ }
++}
++
++static void
++png_read_filter_row_up(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ png_size_t i;
++ png_size_t istop = row_info->rowbytes;
++ png_bytep rp = row;
++ png_const_bytep pp = prev_row;
++
++ for (i = 0; i < istop; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
++ rp++;
++ }
++}
++
++static void
++png_read_filter_row_avg(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ png_size_t i;
++ png_bytep rp = row;
++ png_const_bytep pp = prev_row;
++ unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
++ png_size_t istop = row_info->rowbytes - bpp;
++
++ for (i = 0; i < bpp; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ ((int)(*pp++) / 2 )) & 0xff);
++
++ rp++;
++ }
++
++ for (i = 0; i < istop; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++
++ rp++;
++ }
++}
++
++static void
++png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ png_bytep rp_end = row + row_info->rowbytes;
++ int a, c;
++
++ /* First pixel/byte */
++ c = *prev_row++;
++ a = *row + c;
++ *row++ = (png_byte)a;
++
++ /* Remainder */
++ while (row < rp_end)
++ {
++ int b, pa, pb, pc, p;
++
++ a &= 0xff; /* From previous iteration or start */
++ b = *prev_row++;
++
++ p = b - c;
++ pc = a - c;
++
++# ifdef PNG_USE_ABS
++ pa = abs(p);
++ pb = abs(pc);
++ pc = abs(p + pc);
++# else
++ pa = p < 0 ? -p : p;
++ pb = pc < 0 ? -pc : pc;
++ pc = (p + pc) < 0 ? -(p + pc) : p + pc;
++# endif
++
++ /* Find the best predictor, the least of pa, pb, pc favoring the earlier
++ * ones in the case of a tie.
++ */
++ if (pb < pa) pa = pb, a = b;
++ if (pc < pa) a = c;
++
++ /* Calculate the current pixel in a, and move the previous row pixel to c
++ * for the next time round the loop
++ */
++ c = b;
++ a += *row;
++ *row++ = (png_byte)a;
++ }
++}
++
++static void
++png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ int bpp = (row_info->pixel_depth + 7) >> 3;
++ png_bytep rp_end = row + bpp;
++
++ /* Process the first pixel in the row completely (this is the same as 'up'
++ * because there is only one candidate predictor for the first row).
++ */
++ while (row < rp_end)
++ {
++ int a = *row + *prev_row++;
++ *row++ = (png_byte)a;
++ }
++
++ /* Remainder */
++ rp_end += row_info->rowbytes - bpp;
++
++ while (row < rp_end)
++ {
++ int a, b, c, pa, pb, pc, p;
++
++ c = *(prev_row - bpp);
++ a = *(row - bpp);
++ b = *prev_row++;
++
++ p = b - c;
++ pc = a - c;
++
++# ifdef PNG_USE_ABS
++ pa = abs(p);
++ pb = abs(pc);
++ pc = abs(p + pc);
++# else
++ pa = p < 0 ? -p : p;
++ pb = pc < 0 ? -pc : pc;
++ pc = (p + pc) < 0 ? -(p + pc) : p + pc;
++# endif
++
++ if (pb < pa) pa = pb, a = b;
++ if (pc < pa) a = c;
++
++ a += *row;
++ *row++ = (png_byte)a;
++ }
++}
++
++static void
++png_init_filter_functions(png_structrp pp)
++ /* This function is called once for every PNG image (except for PNG images
++ * that only use PNG_FILTER_VALUE_NONE for all rows) 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 correctly if the image is interlaced -
++ * interlacing causes the actual row width to vary.
++ */
++{
++ unsigned int bpp = (pp->pixel_depth + 7) >> 3;
++
++ pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub;
++ pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up;
++ pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg;
++ if (bpp == 1)
++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
++ png_read_filter_row_paeth_1byte_pixel;
++ else
++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
++ png_read_filter_row_paeth_multibyte_pixel;
++
++#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
++}
+
+ void /* PRIVATE */
+-png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
+- png_const_bytep prev_row, int filter)
++png_read_filter_row(png_structrp pp, png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row, int filter)
+ {
+- png_debug(1, "in png_read_filter_row");
+- png_debug2(2, "row = %u, filter = %d", png_ptr->row_number, filter);
+- switch (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 (filter > PNG_FILTER_VALUE_NONE && filter < PNG_FILTER_VALUE_LAST)
+ {
+- case PNG_FILTER_VALUE_NONE:
+- break;
+-
+- case PNG_FILTER_VALUE_SUB:
++ if (pp->read_filter[0] == NULL)
++ png_init_filter_functions(pp);
++
++ pp->read_filter[filter-1](row_info, row, prev_row);
++ }
++}
++
++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++void /* PRIVATE */
++png_read_IDAT_data(png_structrp png_ptr, png_bytep output,
++ png_alloc_size_t avail_out)
++{
++ /* Loop reading IDATs and decompressing the result into output[avail_out] */
++ png_ptr->zstream.next_out = output;
++ png_ptr->zstream.avail_out = 0; /* safety: set below */
++
++ if (output == NULL)
++ avail_out = 0;
++
++ do
++ {
++ int ret;
++ png_byte tmpbuf[PNG_INFLATE_BUF_SIZE];
++
++ if (png_ptr->zstream.avail_in == 0)
+ {
+- png_size_t i;
+- png_size_t istop = row_info->rowbytes;
+- unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
+- png_bytep rp = row + bpp;
+- png_bytep lp = row;
+-
+- for (i = bpp; i < istop; i++)
++ uInt avail_in;
++ png_bytep buffer;
++
++ while (png_ptr->idat_size == 0)
+ {
+- *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);
+- rp++;
++ png_crc_finish(png_ptr, 0);
++
++ png_ptr->idat_size = png_read_chunk_header(png_ptr);
++ /* This is an error even in the 'check' case because the code just
++ * consumed a non-IDAT header.
++ */
++ if (png_ptr->chunk_name != png_IDAT)
++ png_error(png_ptr, "Not enough image data");
+ }
++
++ avail_in = png_ptr->IDAT_read_size;
++
++ if (avail_in > png_ptr->idat_size)
++ avail_in = (uInt)png_ptr->idat_size;
++
++ /* A PNG with a gradually increasing IDAT size will defeat this attempt
++ * to minimize memory usage by causing lots of re-allocs, but
++ * realistically doing IDAT_read_size re-allocs is not likely to be a
++ * big problem.
++ */
++ buffer = png_read_buffer(png_ptr, avail_in, 0/*error*/);
++
++ png_crc_read(png_ptr, buffer, avail_in);
++ png_ptr->idat_size -= avail_in;
++
++ png_ptr->zstream.next_in = buffer;
++ png_ptr->zstream.avail_in = avail_in;
++ }
++
++ /* And set up the output side. */
++ if (output != NULL) /* standard read */
++ {
++ uInt out = ZLIB_IO_MAX;
++
++ if (out > avail_out)
++ out = (uInt)avail_out;
++
++ avail_out -= out;
++ png_ptr->zstream.avail_out = out;
++ }
++
++ else /* after last row, checking for end */
++ {
++ png_ptr->zstream.next_out = tmpbuf;
++ png_ptr->zstream.avail_out = (sizeof tmpbuf);
++ }
++
++ /* Use NO_FLUSH; this gives zlib the maximum opportunity to optimize the
++ * process. If the LZ stream is truncated the sequential reader will
++ * terminally damage the stream, above, by reading the chunk header of the
++ * following chunk (it then exits with png_error).
++ *
++ * TODO: deal more elegantly with truncated IDAT lists.
++ */
++ ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
++
++ /* Take the unconsumed output back. */
++ if (output != NULL)
++ avail_out += png_ptr->zstream.avail_out;
++
++ else /* avail_out counts the extra bytes */
++ avail_out += (sizeof tmpbuf) - png_ptr->zstream.avail_out;
++
++ png_ptr->zstream.avail_out = 0;
++
++ if (ret == Z_STREAM_END)
++ {
++ /* Do this for safety; we won't read any more into this row. */
++ png_ptr->zstream.next_out = NULL;
++
++ png_ptr->mode |= PNG_AFTER_IDAT;
++ png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
++
++ if (png_ptr->zstream.avail_in > 0 || png_ptr->idat_size > 0)
++ png_chunk_benign_error(png_ptr, "Extra compressed data");
+ break;
+ }
+- case PNG_FILTER_VALUE_UP:
++
++ if (ret != Z_OK)
+ {
+- png_size_t i;
+- png_size_t istop = row_info->rowbytes;
+- png_bytep rp = row;
+- png_const_bytep pp = prev_row;
+-
+- for (i = 0; i < istop; i++)
++ png_zstream_error(png_ptr, ret);
++
++ if (output != NULL)
++ png_chunk_error(png_ptr, png_ptr->zstream.msg);
++
++ else /* checking */
+ {
+- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+- rp++;
++ png_chunk_benign_error(png_ptr, png_ptr->zstream.msg);
++ return;
+ }
+- break;
+ }
+- case PNG_FILTER_VALUE_AVG:
+- {
+- png_size_t i;
+- png_bytep rp = row;
+- png_const_bytep pp = prev_row;
+- png_bytep lp = row;
+- unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
+- png_size_t istop = row_info->rowbytes - bpp;
+-
+- for (i = 0; i < bpp; i++)
+- {
+- *rp = (png_byte)(((int)(*rp) +
+- ((int)(*pp++) / 2 )) & 0xff);
+-
+- rp++;
+- }
+-
+- for (i = 0; i < istop; i++)
+- {
+- *rp = (png_byte)(((int)(*rp) +
+- (int)(*pp++ + *lp++) / 2 ) & 0xff);
+-
+- rp++;
+- }
+- break;
+- }
+- case PNG_FILTER_VALUE_PAETH:
+- {
+- png_size_t i;
+- png_bytep rp = row;
+- png_const_bytep pp = prev_row;
+- png_bytep lp = row;
+- png_const_bytep cp = prev_row;
+- unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
+- png_size_t istop=row_info->rowbytes - bpp;
+-
+- for (i = 0; i < bpp; i++)
+- {
+- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+- rp++;
+- }
+-
+- for (i = 0; i < istop; i++) /* Use leftover rp,pp */
+- {
+- int a, b, c, pa, pb, pc, p;
+-
+- a = *lp++;
+- b = *pp++;
+- c = *cp++;
+-
+- p = b - c;
+- pc = a - c;
+-
+-#ifdef PNG_USE_ABS
+- pa = abs(p);
+- pb = abs(pc);
+- pc = abs(p + pc);
+-#else
+- pa = p < 0 ? -p : p;
+- pb = pc < 0 ? -pc : pc;
+- pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+-#endif
+-
+- /*
+- if (pa <= pb && pa <= pc)
+- p = a;
+-
+- else if (pb <= pc)
+- p = b;
+-
+- else
+- p = c;
+- */
+-
+- p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+-
+- *rp = (png_byte)(((int)(*rp) + p) & 0xff);
+- rp++;
+- }
+- break;
+- }
+- default:
+- png_error(png_ptr, "Ignoring bad adaptive filter type");
+- /*NOT REACHED */
+- break;
++ } while (avail_out > 0);
++
++ if (avail_out > 0)
++ {
++ /* The stream ended before the image; this is the same as too few IDATs so
++ * should be handled the same way.
++ */
++ if (output != NULL)
++ png_error(png_ptr, "Not enough image data");
++
++ else /* the deflate stream contained extra data */
++ png_chunk_benign_error(png_ptr, "Too much image data");
+ }
+ }
+
+-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+ void /* PRIVATE */
+-png_read_finish_row(png_structp png_ptr)
++png_read_finish_IDAT(png_structrp png_ptr)
+ {
+-#ifdef PNG_READ_INTERLACING_SUPPORTED
++ /* We don't need any more data and the stream should have ended, however the
++ * LZ end code may actually not have been processed. In this case we must
++ * read it otherwise stray unread IDAT data or, more likely, an IDAT chunk
++ * may still remain to be consumed.
++ */
++ if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
++ {
++ /* The NULL causes png_read_IDAT_data to swallow any remaining bytes in
++ * the compressed stream, but the stream may be damaged too, so even after
++ * this call we may need to terminate the zstream ownership.
++ */
++ png_read_IDAT_data(png_ptr, NULL, 0);
++ png_ptr->zstream.next_out = NULL; /* safety */
++
++ /* Now clear everything out for safety; the following may not have been
++ * done.
++ */
++ if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
++ {
++ png_ptr->mode |= PNG_AFTER_IDAT;
++ png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
++ }
++ }
++
++ /* If the zstream has not been released do it now *and* terminate the reading
++ * of the final IDAT chunk.
++ */
++ if (png_ptr->zowner == png_IDAT)
++ {
++ /* Always do this; the pointers otherwise point into the read buffer. */
++ png_ptr->zstream.next_in = NULL;
++ png_ptr->zstream.avail_in = 0;
++
++ /* Now we no longer own the zstream. */
++ png_ptr->zowner = 0;
++
++ /* The slightly weird semantics of the sequential IDAT reading is that we
++ * are always in or at the end of an IDAT chunk, so we always need to do a
++ * crc_finish here. If idat_size is non-zero we also need to read the
++ * spurious bytes at the end of the chunk now.
++ */
++ (void)png_crc_finish(png_ptr, png_ptr->idat_size);
++ }
++}
++
++void /* PRIVATE */
++png_read_finish_row(png_structrp png_ptr)
++{
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* Start of interlace block */
+- PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
++ static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* Offset to next interlace block */
+- PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* Start of interlace block in the y direction */
+- PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
++ static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* Offset to next interlace block in the y direction */
+- PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+-#endif /* PNG_READ_INTERLACING_SUPPORTED */
++ static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+
+ png_debug(1, "in png_read_finish_row");
+ png_ptr->row_number++;
+ if (png_ptr->row_number < png_ptr->num_rows)
+ return;
+
+-#ifdef PNG_READ_INTERLACING_SUPPORTED
+- if (png_ptr->interlaced)
++ if (png_ptr->interlaced != 0)
+ {
+ png_ptr->row_number = 0;
+
+- png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
++ /* TO DO: don't do this if prev_row isn't needed (requires
++ * read-ahead of the next row's filter byte.
++ */
++ memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+
+ do
+ {
+@@ -3347,7 +4186,7 @@
+ png_pass_start[png_ptr->pass]) /
+ png_pass_inc[png_ptr->pass];
+
+- if (!(png_ptr->transformations & PNG_INTERLACE))
++ if ((png_ptr->transformations & PNG_INTERLACE) == 0)
+ {
+ png_ptr->num_rows = (png_ptr->height +
+ png_pass_yinc[png_ptr->pass] - 1 -
+@@ -3363,108 +4202,40 @@
+ if (png_ptr->pass < 7)
+ return;
+ }
+-#endif /* PNG_READ_INTERLACING_SUPPORTED */
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
+- {
+- PNG_IDAT;
+- char extra;
+- int ret;
+-
+- png_ptr->zstream.next_out = (Byte *)&extra;
+- png_ptr->zstream.avail_out = (uInt)1;
+-
+- for (;;)
+- {
+- if (!(png_ptr->zstream.avail_in))
+- {
+- while (!png_ptr->idat_size)
+- {
+- png_crc_finish(png_ptr, 0);
+- png_ptr->idat_size = png_read_chunk_header(png_ptr);
+- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
+- png_error(png_ptr, "Not enough image data");
+- }
+-
+- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
+- png_ptr->zstream.next_in = png_ptr->zbuf;
+-
+- if (png_ptr->zbuf_size > png_ptr->idat_size)
+- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
+-
+- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);
+- png_ptr->idat_size -= png_ptr->zstream.avail_in;
+- }
+-
+- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
+-
+- if (ret == Z_STREAM_END)
+- {
+- if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||
+- png_ptr->idat_size)
+- png_warning(png_ptr, "Extra compressed data");
+-
+- png_ptr->mode |= PNG_AFTER_IDAT;
+- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+- break;
+- }
+-
+- if (ret != Z_OK)
+- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
+- "Decompression Error");
+-
+- if (!(png_ptr->zstream.avail_out))
+- {
+- png_warning(png_ptr, "Extra compressed data");
+- png_ptr->mode |= PNG_AFTER_IDAT;
+- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
+- break;
+- }
+-
+- }
+- png_ptr->zstream.avail_out = 0;
+- }
+-
+- if (png_ptr->idat_size || png_ptr->zstream.avail_in)
+- png_warning(png_ptr, "Extra compression data");
+-
+- inflateReset(&png_ptr->zstream);
+-
+- png_ptr->mode |= PNG_AFTER_IDAT;
++
++ /* Here after at the end of the last row of the last pass. */
++ png_read_finish_IDAT(png_ptr);
+ }
+-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
++#endif /* SEQUENTIAL_READ */
+
+ void /* PRIVATE */
+-png_read_start_row(png_structp png_ptr)
++png_read_start_row(png_structrp png_ptr)
+ {
+-#ifdef PNG_READ_INTERLACING_SUPPORTED
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* Start of interlace block */
+- PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
++ static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* Offset to next interlace block */
+- PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* Start of interlace block in the y direction */
+- PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
++ static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* Offset to next interlace block in the y direction */
+- PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+-#endif
++ static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+
+ int max_pixel_depth;
+ png_size_t row_bytes;
+
+ png_debug(1, "in png_read_start_row");
+- png_ptr->zstream.avail_in = 0;
++
+ #ifdef PNG_READ_TRANSFORMS_SUPPORTED
+ png_init_read_transformations(png_ptr);
+ #endif
+-#ifdef PNG_READ_INTERLACING_SUPPORTED
+- if (png_ptr->interlaced)
++ if (png_ptr->interlaced != 0)
+ {
+- if (!(png_ptr->transformations & PNG_INTERLACE))
++ if ((png_ptr->transformations & PNG_INTERLACE) == 0)
+ png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
+ png_pass_ystart[0]) / png_pass_yinc[0];
+
+@@ -3478,7 +4249,6 @@
+ }
+
+ else
+-#endif /* PNG_READ_INTERLACING_SUPPORTED */
+ {
+ png_ptr->num_rows = png_ptr->height;
+ png_ptr->iwidth = png_ptr->width;
+@@ -3486,17 +4256,27 @@
+
+ max_pixel_depth = png_ptr->pixel_depth;
+
++ /* WARNING: * png_read_transform_info (pngrtran.c) performs a simpler set of
++ * calculations to calculate the final pixel depth, then
++ * png_do_read_transforms actually does the transforms. This means that the
++ * code which effectively calculates this value is actually repeated in three
++ * separate places. They must all match. Innocent changes to the order of
++ * transformations can and will break libpng in a way that causes memory
++ * overwrites.
++ *
++ * TODO: fix this.
++ */
+ #ifdef PNG_READ_PACK_SUPPORTED
+- if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
++ if ((png_ptr->transformations & PNG_PACK) != 0 && png_ptr->bit_depth < 8)
+ max_pixel_depth = 8;
+ #endif
+
+ #ifdef PNG_READ_EXPAND_SUPPORTED
+- if (png_ptr->transformations & PNG_EXPAND)
++ if ((png_ptr->transformations & PNG_EXPAND) != 0)
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+- if (png_ptr->num_trans)
++ if (png_ptr->num_trans != 0)
+ max_pixel_depth = 32;
+
+ else
+@@ -3508,13 +4288,13 @@
+ if (max_pixel_depth < 8)
+ max_pixel_depth = 8;
+
+- if (png_ptr->num_trans)
++ if (png_ptr->num_trans != 0)
+ max_pixel_depth *= 2;
+ }
+
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+ {
+- if (png_ptr->num_trans)
++ if (png_ptr->num_trans != 0)
+ {
+ max_pixel_depth *= 4;
+ max_pixel_depth /= 3;
+@@ -3524,13 +4304,13 @@
+ #endif
+
+ #ifdef PNG_READ_EXPAND_16_SUPPORTED
+- if (png_ptr->transformations & PNG_EXPAND_16)
++ if ((png_ptr->transformations & PNG_EXPAND_16) != 0)
+ {
+ # ifdef PNG_READ_EXPAND_SUPPORTED
+ /* In fact it is an error if it isn't supported, but checking is
+ * the safe way.
+ */
+- if (png_ptr->transformations & PNG_EXPAND)
++ if ((png_ptr->transformations & PNG_EXPAND) != 0)
+ {
+ if (png_ptr->bit_depth < 16)
+ max_pixel_depth *= 2;
+@@ -3542,12 +4322,9 @@
+ #endif
+
+ #ifdef PNG_READ_FILLER_SUPPORTED
+- if (png_ptr->transformations & (PNG_FILLER))
++ if ((png_ptr->transformations & (PNG_FILLER)) != 0)
+ {
+- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+- max_pixel_depth = 32;
+-
+- else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
++ if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+ {
+ if (max_pixel_depth <= 8)
+ max_pixel_depth = 16;
+@@ -3556,7 +4333,8 @@
+ max_pixel_depth = 32;
+ }
+
+- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
++ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB ||
++ png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (max_pixel_depth <= 32)
+ max_pixel_depth = 32;
+@@ -3568,14 +4346,15 @@
+ #endif
+
+ #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+- if (png_ptr->transformations & PNG_GRAY_TO_RGB)
++ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
+ {
+ if (
+ #ifdef PNG_READ_EXPAND_SUPPORTED
+- (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
++ (png_ptr->num_trans != 0 &&
++ (png_ptr->transformations & PNG_EXPAND) != 0) ||
+ #endif
+ #ifdef PNG_READ_FILLER_SUPPORTED
+- (png_ptr->transformations & (PNG_FILLER)) ||
++ (png_ptr->transformations & (PNG_FILLER)) != 0 ||
+ #endif
+ png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ {
+@@ -3608,16 +4387,22 @@
+
+ #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \
+ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+- if (png_ptr->transformations & PNG_USER_TRANSFORM)
++ if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
+ {
+- int user_pixel_depth = png_ptr->user_transform_depth*
++ int user_pixel_depth = png_ptr->user_transform_depth *
+ png_ptr->user_transform_channels;
+
+ if (user_pixel_depth > max_pixel_depth)
+- max_pixel_depth=user_pixel_depth;
++ max_pixel_depth = user_pixel_depth;
+ }
+ #endif
+
++ /* This value is stored in png_struct and double checked in the row read
++ * code.
++ */
++ png_ptr->maximum_pixel_depth = (png_byte)max_pixel_depth;
++ png_ptr->transformed_pixel_depth = 0; /* calculated on demand */
++
+ /* Align the width on the next larger 8 pixels. Mainly used
+ * for interlacing
+ */
+@@ -3636,28 +4421,39 @@
+ if (row_bytes + 48 > png_ptr->old_big_row_buf_size)
+ {
+ png_free(png_ptr, png_ptr->big_row_buf);
+-
+- if (png_ptr->interlaced)
++ png_free(png_ptr, png_ptr->big_prev_row);
++
++ if (png_ptr->interlaced != 0)
+ png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
+ row_bytes + 48);
+
+ else
+- png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,
+- row_bytes + 48);
+-
+- png_ptr->old_big_row_buf_size = row_bytes + 48;
++ png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
++
++ png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
+
+ #ifdef PNG_ALIGNED_MEMORY_SUPPORTED
+ /* Use 16-byte aligned memory for row_buf with at least 16 bytes
+- * of padding before and after row_buf.
++ * of padding before and after row_buf; treat prev_row similarly.
++ * NOTE: the alignment is to the start of the pixels, one beyond the start
++ * of the buffer, because of the filter byte. Prior to libpng 1.5.6 this
++ * was incorrect; the filter byte was aligned, which had the exact
++ * opposite effect of that intended.
+ */
+- png_ptr->row_buf = png_ptr->big_row_buf + 32 -
+- (((png_alloc_size_t)png_ptr->big_row_buf + 15) & 0x0F);
+-
+- png_ptr->old_big_row_buf_size = row_bytes + 48;
++ {
++ png_bytep temp = png_ptr->big_row_buf + 32;
++ int extra = (int)((temp - (png_bytep)0) & 0x0f);
++ png_ptr->row_buf = temp - extra - 1/*filter byte*/;
++
++ temp = png_ptr->big_prev_row + 32;
++ extra = (int)((temp - (png_bytep)0) & 0x0f);
++ png_ptr->prev_row = temp - extra - 1/*filter byte*/;
++ }
++
+ #else
+- /* Use 32 bytes of padding before and 16 bytes after row_buf. */
+- png_ptr->row_buf = png_ptr->big_row_buf + 32;
++ /* Use 31 bytes of padding before and 17 bytes after row_buf. */
++ png_ptr->row_buf = png_ptr->big_row_buf + 31;
++ png_ptr->prev_row = png_ptr->big_prev_row + 31;
+ #endif
+ png_ptr->old_big_row_buf_size = row_bytes + 48;
+ }
+@@ -3670,16 +4466,7 @@
+ if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1))
+ png_error(png_ptr, "Row has too many bytes to allocate in memory");
+
+- if (png_ptr->rowbytes + 1 > png_ptr->old_prev_row_size)
+- {
+- png_free(png_ptr, png_ptr->prev_row);
+-
+- png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);
+-
+- png_ptr->old_prev_row_size = png_ptr->rowbytes + 1;
+- }
+-
+- png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
++ memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+
+ png_debug1(3, "width = %u,", png_ptr->width);
+ png_debug1(3, "height = %u,", png_ptr->height);
+@@ -3689,6 +4476,27 @@
+ png_debug1(3, "irowbytes = %lu",
+ (unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
+
++ /* The sequential reader needs a buffer for IDAT, but the progressive reader
++ * does not, so free the read buffer now regardless; the sequential reader
++ * reallocates it on demand.
++ */
++ if (png_ptr->read_buffer != 0)
++ {
++ png_bytep buffer = png_ptr->read_buffer;
++
++ png_ptr->read_buffer_size = 0;
++ png_ptr->read_buffer = NULL;
++ png_free(png_ptr, buffer);
++ }
++
++ /* Finally claim the zstream for the inflate of the IDAT data, use the bits
++ * value from the stream (note that this will result in a fatal error if the
++ * IDAT stream has a bogus deflate header window_bits value, but this should
++ * not be happening any longer!)
++ */
++ if (png_inflate_claim(png_ptr, png_IDAT) != Z_OK)
++ png_error(png_ptr, png_ptr->zstream.msg);
++
+ png_ptr->flags |= PNG_FLAG_ROW_INIT;
+ }
+-#endif /* PNG_READ_SUPPORTED */
++#endif /* READ */
+--- ./jdk/src/share/native/sun/awt/libpng/pngset.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngset.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -50,51 +50,84 @@
+
+ #ifdef PNG_bKGD_SUPPORTED
+ void PNGAPI
+-png_set_bKGD(png_structp png_ptr, png_infop info_ptr,
++png_set_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_const_color_16p background)
+ {
+ png_debug1(1, "in %s storage function", "bKGD");
+
+- if (png_ptr == NULL || info_ptr == NULL)
++ if (png_ptr == NULL || info_ptr == NULL || background == NULL)
+ return;
+
+- png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
++ info_ptr->background = *background;
+ info_ptr->valid |= PNG_INFO_bKGD;
+ }
+ #endif
+
+ #ifdef PNG_cHRM_SUPPORTED
+ void PNGFAPI
+-png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
++png_set_cHRM_fixed(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
+ png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
+ png_fixed_point blue_x, png_fixed_point blue_y)
+ {
++ png_xy xy;
++
+ png_debug1(1, "in %s storage function", "cHRM fixed");
+
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+-# ifdef PNG_CHECK_cHRM_SUPPORTED
+- if (png_check_cHRM_fixed(png_ptr,
+- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))
+-# endif
+- {
+- info_ptr->x_white = white_x;
+- info_ptr->y_white = white_y;
+- info_ptr->x_red = red_x;
+- info_ptr->y_red = red_y;
+- info_ptr->x_green = green_x;
+- info_ptr->y_green = green_y;
+- info_ptr->x_blue = blue_x;
+- info_ptr->y_blue = blue_y;
+- info_ptr->valid |= PNG_INFO_cHRM;
+- }
++ xy.redx = red_x;
++ xy.redy = red_y;
++ xy.greenx = green_x;
++ xy.greeny = green_y;
++ xy.bluex = blue_x;
++ xy.bluey = blue_y;
++ xy.whitex = white_x;
++ xy.whitey = white_y;
++
++ if (png_colorspace_set_chromaticities(png_ptr, &info_ptr->colorspace, &xy,
++ 2/* override with app values*/) != 0)
++ info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
++
++ png_colorspace_sync_info(png_ptr, info_ptr);
++}
++
++void PNGFAPI
++png_set_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_inforp info_ptr,
++ png_fixed_point int_red_X, png_fixed_point int_red_Y,
++ png_fixed_point int_red_Z, png_fixed_point int_green_X,
++ png_fixed_point int_green_Y, png_fixed_point int_green_Z,
++ png_fixed_point int_blue_X, png_fixed_point int_blue_Y,
++ png_fixed_point int_blue_Z)
++{
++ png_XYZ XYZ;
++
++ png_debug1(1, "in %s storage function", "cHRM XYZ fixed");
++
++ if (png_ptr == NULL || info_ptr == NULL)
++ return;
++
++ XYZ.red_X = int_red_X;
++ XYZ.red_Y = int_red_Y;
++ XYZ.red_Z = int_red_Z;
++ XYZ.green_X = int_green_X;
++ XYZ.green_Y = int_green_Y;
++ XYZ.green_Z = int_green_Z;
++ XYZ.blue_X = int_blue_X;
++ XYZ.blue_Y = int_blue_Y;
++ XYZ.blue_Z = int_blue_Z;
++
++ if (png_colorspace_set_endpoints(png_ptr, &info_ptr->colorspace,
++ &XYZ, 2) != 0)
++ info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
++
++ png_colorspace_sync_info(png_ptr, info_ptr);
+ }
+
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ void PNGAPI
+-png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
++png_set_cHRM(png_const_structrp png_ptr, png_inforp info_ptr,
+ double white_x, double white_y, double red_x, double red_y,
+ double green_x, double green_y, double blue_x, double blue_y)
+ {
+@@ -108,41 +141,44 @@
+ png_fixed(png_ptr, blue_x, "cHRM Blue X"),
+ png_fixed(png_ptr, blue_y, "cHRM Blue Y"));
+ }
+-# endif /* PNG_FLOATING_POINT_SUPPORTED */
+
+-#endif /* PNG_cHRM_SUPPORTED */
++void PNGAPI
++png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr, double red_X,
++ double red_Y, double red_Z, double green_X, double green_Y, double green_Z,
++ double blue_X, double blue_Y, double blue_Z)
++{
++ png_set_cHRM_XYZ_fixed(png_ptr, info_ptr,
++ png_fixed(png_ptr, red_X, "cHRM Red X"),
++ png_fixed(png_ptr, red_Y, "cHRM Red Y"),
++ png_fixed(png_ptr, red_Z, "cHRM Red Z"),
++ png_fixed(png_ptr, green_X, "cHRM Red X"),
++ png_fixed(png_ptr, green_Y, "cHRM Red Y"),
++ png_fixed(png_ptr, green_Z, "cHRM Red Z"),
++ png_fixed(png_ptr, blue_X, "cHRM Red X"),
++ png_fixed(png_ptr, blue_Y, "cHRM Red Y"),
++ png_fixed(png_ptr, blue_Z, "cHRM Red Z"));
++}
++# endif /* FLOATING_POINT */
++
++#endif /* cHRM */
+
+ #ifdef PNG_gAMA_SUPPORTED
+ void PNGFAPI
+-png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
+- file_gamma)
++png_set_gAMA_fixed(png_const_structrp png_ptr, png_inforp info_ptr,
++ png_fixed_point file_gamma)
+ {
+ png_debug1(1, "in %s storage function", "gAMA");
+
+ 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 truely ridiculous gammma values (and will produce
+- * displays that are all black or all white.)
+- */
+- if (file_gamma < 16 || file_gamma > 625000000)
+- png_warning(png_ptr, "Out of range gamma value ignored");
+-
+- else
+- {
+- info_ptr->gamma = file_gamma;
+- info_ptr->valid |= PNG_INFO_gAMA;
+- }
++ png_colorspace_set_gamma(png_ptr, &info_ptr->colorspace, file_gamma);
++ png_colorspace_sync_info(png_ptr, info_ptr);
+ }
+
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ void PNGAPI
+-png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
++png_set_gAMA(png_const_structrp png_ptr, png_inforp info_ptr, double file_gamma)
+ {
+ png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma,
+ "png_set_gAMA"));
+@@ -152,7 +188,8 @@
+
+ #ifdef PNG_hIST_SUPPORTED
+ void PNGAPI
+-png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_const_uint_16p hist)
++png_set_hIST(png_const_structrp png_ptr, png_inforp info_ptr,
++ png_const_uint_16p hist)
+ {
+ int i;
+
+@@ -175,26 +212,26 @@
+ /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
+ * version 1.2.1
+ */
+- png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
+- PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16));
++ info_ptr->hist = png_voidcast(png_uint_16p, png_malloc_warn(png_ptr,
++ PNG_MAX_PALETTE_LENGTH * (sizeof (png_uint_16))));
+
+- if (png_ptr->hist == NULL)
++ if (info_ptr->hist == NULL)
+ {
+ png_warning(png_ptr, "Insufficient memory for hIST chunk data");
+ return;
+ }
+
++ info_ptr->free_me |= PNG_FREE_HIST;
++
+ for (i = 0; i < info_ptr->num_palette; i++)
+- png_ptr->hist[i] = hist[i];
++ info_ptr->hist[i] = hist[i];
+
+- info_ptr->hist = png_ptr->hist;
+ info_ptr->valid |= PNG_INFO_hIST;
+- info_ptr->free_me |= PNG_FREE_HIST;
+ }
+ #endif
+
+ void PNGAPI
+-png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
++png_set_IHDR(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_uint_32 width, png_uint_32 height, int bit_depth,
+ int color_type, int interlace_type, int compression_type,
+ int filter_type)
+@@ -219,32 +256,23 @@
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ info_ptr->channels = 1;
+
+- else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
++ else if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
+ info_ptr->channels = 3;
+
+ else
+ info_ptr->channels = 1;
+
+- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
++ if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
+ info_ptr->channels++;
+
+ info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
+
+- /* Check for potential overflow */
+- if (width >
+- (PNG_UINT_32_MAX >> 3) /* 8-byte RRGGBBAA pixels */
+- - 48 /* bigrowbuf hack */
+- - 1 /* filter byte */
+- - 7*8 /* rounding of width to multiple of 8 pixels */
+- - 8) /* extra max_pixel_depth pad */
+- info_ptr->rowbytes = 0;
+- else
+- info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
++ info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
+ }
+
+ #ifdef PNG_oFFs_SUPPORTED
+ void PNGAPI
+-png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
++png_set_oFFs(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_int_32 offset_x, png_int_32 offset_y, int unit_type)
+ {
+ png_debug1(1, "in %s storage function", "oFFs");
+@@ -261,7 +289,7 @@
+
+ #ifdef PNG_pCAL_SUPPORTED
+ void PNGAPI
+-png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
++png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type,
+ int nparams, png_const_charp units, png_charpp params)
+ {
+@@ -270,10 +298,11 @@
+
+ png_debug1(1, "in %s storage function", "pCAL");
+
+- if (png_ptr == NULL || info_ptr == NULL)
++ if (png_ptr == NULL || info_ptr == NULL || purpose == NULL || units == NULL
++ || (nparams > 0 && params == NULL))
+ return;
+
+- length = png_strlen(purpose) + 1;
++ length = strlen(purpose) + 1;
+ png_debug1(3, "allocating purpose for info (%lu bytes)",
+ (unsigned long)length);
+
+@@ -283,12 +312,19 @@
+ if (type < 0 || type > 3)
+ png_error(png_ptr, "Invalid pCAL equation type");
+
++ if (nparams < 0 || nparams > 255)
++ png_error(png_ptr, "Invalid pCAL parameter count");
++
+ /* Validate params[nparams] */
+ for (i=0; i<nparams; ++i)
+- if (!png_check_fp_string(params[i], png_strlen(params[i])))
++ {
++ if (params[i] == NULL ||
++ !png_check_fp_string(params[i], strlen(params[i])))
+ png_error(png_ptr, "Invalid format for pCAL parameter");
++ }
+
+- info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
++ info_ptr->pcal_purpose = png_voidcast(png_charp,
++ png_malloc_warn(png_ptr, length));
+
+ if (info_ptr->pcal_purpose == NULL)
+ {
+@@ -296,7 +332,7 @@
+ return;
+ }
+
+- png_memcpy(info_ptr->pcal_purpose, purpose, length);
++ memcpy(info_ptr->pcal_purpose, purpose, length);
+
+ png_debug(3, "storing X0, X1, type, and nparams in info");
+ info_ptr->pcal_X0 = X0;
+@@ -304,11 +340,12 @@
+ info_ptr->pcal_type = (png_byte)type;
+ info_ptr->pcal_nparams = (png_byte)nparams;
+
+- length = png_strlen(units) + 1;
++ length = strlen(units) + 1;
+ png_debug1(3, "allocating units for info (%lu bytes)",
+ (unsigned long)length);
+
+- info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
++ info_ptr->pcal_units = png_voidcast(png_charp,
++ png_malloc_warn(png_ptr, length));
+
+ if (info_ptr->pcal_units == NULL)
+ {
+@@ -316,10 +353,10 @@
+ return;
+ }
+
+- png_memcpy(info_ptr->pcal_units, units, length);
++ memcpy(info_ptr->pcal_units, units, length);
+
+- info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
+- (png_size_t)((nparams + 1) * png_sizeof(png_charp)));
++ info_ptr->pcal_params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
++ (png_size_t)((nparams + 1) * (sizeof (png_charp)))));
+
+ if (info_ptr->pcal_params == NULL)
+ {
+@@ -327,11 +364,11 @@
+ return;
+ }
+
+- png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));
++ memset(info_ptr->pcal_params, 0, (nparams + 1) * (sizeof (png_charp)));
+
+ for (i = 0; i < nparams; i++)
+ {
+- length = png_strlen(params[i]) + 1;
++ length = strlen(params[i]) + 1;
+ png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,
+ (unsigned long)length);
+
+@@ -343,7 +380,7 @@
+ return;
+ }
+
+- png_memcpy(info_ptr->pcal_params[i], params[i], length);
++ memcpy(info_ptr->pcal_params[i], params[i], length);
+ }
+
+ info_ptr->valid |= PNG_INFO_pCAL;
+@@ -353,7 +390,7 @@
+
+ #ifdef PNG_sCAL_SUPPORTED
+ void PNGAPI
+-png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
++png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr,
+ int unit, png_const_charp swidth, png_const_charp sheight)
+ {
+ png_size_t lengthw = 0, lengthh = 0;
+@@ -369,11 +406,11 @@
+ if (unit != 1 && unit != 2)
+ png_error(png_ptr, "Invalid sCAL unit");
+
+- if (swidth == NULL || (lengthw = png_strlen(swidth)) == 0 ||
++ if (swidth == NULL || (lengthw = strlen(swidth)) == 0 ||
+ swidth[0] == 45 /* '-' */ || !png_check_fp_string(swidth, lengthw))
+ png_error(png_ptr, "Invalid sCAL width");
+
+- if (sheight == NULL || (lengthh = png_strlen(sheight)) == 0 ||
++ if (sheight == NULL || (lengthh = strlen(sheight)) == 0 ||
+ sheight[0] == 45 /* '-' */ || !png_check_fp_string(sheight, lengthh))
+ png_error(png_ptr, "Invalid sCAL height");
+
+@@ -383,7 +420,8 @@
+
+ png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw);
+
+- info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, lengthw);
++ info_ptr->scal_s_width = png_voidcast(png_charp,
++ png_malloc_warn(png_ptr, lengthw));
+
+ if (info_ptr->scal_s_width == NULL)
+ {
+@@ -391,13 +429,14 @@
+ return;
+ }
+
+- png_memcpy(info_ptr->scal_s_width, swidth, lengthw);
++ memcpy(info_ptr->scal_s_width, swidth, lengthw);
+
+ ++lengthh;
+
+ png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh);
+
+- info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, lengthh);
++ info_ptr->scal_s_height = png_voidcast(png_charp,
++ png_malloc_warn(png_ptr, lengthh));
+
+ if (info_ptr->scal_s_height == NULL)
+ {
+@@ -408,7 +447,7 @@
+ return;
+ }
+
+- png_memcpy(info_ptr->scal_s_height, sheight, lengthh);
++ memcpy(info_ptr->scal_s_height, sheight, lengthh);
+
+ info_ptr->valid |= PNG_INFO_sCAL;
+ info_ptr->free_me |= PNG_FREE_SCAL;
+@@ -416,8 +455,8 @@
+
+ # ifdef PNG_FLOATING_POINT_SUPPORTED
+ void PNGAPI
+-png_set_sCAL(png_structp png_ptr, png_infop info_ptr, int unit, double width,
+- double height)
++png_set_sCAL(png_const_structrp png_ptr, png_inforp info_ptr, int unit,
++ double width, double height)
+ {
+ png_debug1(1, "in %s storage function", "sCAL");
+
+@@ -434,9 +473,9 @@
+ char swidth[PNG_sCAL_MAX_DIGITS+1];
+ char sheight[PNG_sCAL_MAX_DIGITS+1];
+
+- png_ascii_from_fp(png_ptr, swidth, sizeof swidth, width,
++ png_ascii_from_fp(png_ptr, swidth, (sizeof swidth), width,
+ PNG_sCAL_PRECISION);
+- png_ascii_from_fp(png_ptr, sheight, sizeof sheight, height,
++ png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height,
+ PNG_sCAL_PRECISION);
+
+ png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight);
+@@ -446,7 +485,7 @@
+
+ # ifdef PNG_FIXED_POINT_SUPPORTED
+ void PNGAPI
+-png_set_sCAL_fixed(png_structp png_ptr, png_infop info_ptr, int unit,
++png_set_sCAL_fixed(png_const_structrp png_ptr, png_inforp info_ptr, int unit,
+ png_fixed_point width, png_fixed_point height)
+ {
+ png_debug1(1, "in %s storage function", "sCAL");
+@@ -464,8 +503,8 @@
+ char swidth[PNG_sCAL_MAX_DIGITS+1];
+ char sheight[PNG_sCAL_MAX_DIGITS+1];
+
+- png_ascii_from_fixed(png_ptr, swidth, sizeof swidth, width);
+- png_ascii_from_fixed(png_ptr, sheight, sizeof sheight, height);
++ png_ascii_from_fixed(png_ptr, swidth, (sizeof swidth), width);
++ png_ascii_from_fixed(png_ptr, sheight, (sizeof sheight), height);
+
+ png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight);
+ }
+@@ -475,7 +514,7 @@
+
+ #ifdef PNG_pHYs_SUPPORTED
+ void PNGAPI
+-png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
++png_set_pHYs(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_uint_32 res_x, png_uint_32 res_y, int unit_type)
+ {
+ png_debug1(1, "in %s storage function", "pHYs");
+@@ -491,7 +530,7 @@
+ #endif
+
+ void PNGAPI
+-png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
++png_set_PLTE(png_structrp png_ptr, png_inforp info_ptr,
+ png_const_colorp palette, int num_palette)
+ {
+
+@@ -526,6 +565,9 @@
+ /* It may not actually be necessary to set png_ptr->palette here;
+ * we do it for backward compatibility with the way the png_handle_tRNS
+ * function used to do the allocation.
++ *
++ * 1.6.0: the above statement appears to be incorrect; something has to set
++ * the palette inside png_struct on read.
+ */
+ png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
+
+@@ -533,10 +575,11 @@
+ * of num_palette entries, in case of an invalid PNG file that has
+ * too-large sample values.
+ */
+- png_ptr->palette = (png_colorp)png_calloc(png_ptr,
+- PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
++ png_ptr->palette = png_voidcast(png_colorp, png_calloc(png_ptr,
++ PNG_MAX_PALETTE_LENGTH * (sizeof (png_color))));
+
+- png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
++ if (num_palette > 0)
++ memcpy(png_ptr->palette, palette, num_palette * (sizeof (png_color)));
+ info_ptr->palette = png_ptr->palette;
+ info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
+
+@@ -547,34 +590,34 @@
+
+ #ifdef PNG_sBIT_SUPPORTED
+ void PNGAPI
+-png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
++png_set_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_const_color_8p sig_bit)
+ {
+ png_debug1(1, "in %s storage function", "sBIT");
+
+- if (png_ptr == NULL || info_ptr == NULL)
++ if (png_ptr == NULL || info_ptr == NULL || sig_bit == NULL)
+ return;
+
+- png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
++ info_ptr->sig_bit = *sig_bit;
+ info_ptr->valid |= PNG_INFO_sBIT;
+ }
+ #endif
+
+ #ifdef PNG_sRGB_SUPPORTED
+ void PNGAPI
+-png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int srgb_intent)
++png_set_sRGB(png_const_structrp png_ptr, png_inforp info_ptr, int srgb_intent)
+ {
+ png_debug1(1, "in %s storage function", "sRGB");
+
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+- info_ptr->srgb_intent = (png_byte)srgb_intent;
+- info_ptr->valid |= PNG_INFO_sRGB;
++ (void)png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent);
++ png_colorspace_sync_info(png_ptr, info_ptr);
+ }
+
+ void PNGAPI
+-png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
++png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr, png_inforp info_ptr,
+ int srgb_intent)
+ {
+ png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
+@@ -582,71 +625,87 @@
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+- png_set_sRGB(png_ptr, info_ptr, srgb_intent);
++ if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace,
++ srgb_intent) != 0)
++ {
++ /* This causes the gAMA and cHRM to be written too */
++ info_ptr->colorspace.flags |=
++ PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;
++ }
+
+-# ifdef PNG_gAMA_SUPPORTED
+- png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_sRGB_INVERSE);
+-# endif
+-
+-# ifdef PNG_cHRM_SUPPORTED
+- png_set_cHRM_fixed(png_ptr, info_ptr,
+- /* color x y */
+- /* white */ 31270L, 32900L,
+- /* red */ 64000L, 33000L,
+- /* green */ 30000L, 60000L,
+- /* blue */ 15000L, 6000L
+- );
+-# endif /* cHRM */
++ png_colorspace_sync_info(png_ptr, info_ptr);
+ }
+ #endif /* sRGB */
+
+
+ #ifdef PNG_iCCP_SUPPORTED
+ void PNGAPI
+-png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
++png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_const_charp name, int compression_type,
+ png_const_bytep profile, png_uint_32 proflen)
+ {
+ png_charp new_iccp_name;
+ png_bytep new_iccp_profile;
+- png_uint_32 length;
++ png_size_t length;
+
+ png_debug1(1, "in %s storage function", "iCCP");
+
+ if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
+ return;
+
+- length = png_strlen(name)+1;
+- new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
++ if (compression_type != PNG_COMPRESSION_TYPE_BASE)
++ png_app_error(png_ptr, "Invalid iCCP compression method");
++
++ /* Set the colorspace first because this validates the profile; do not
++ * override previously set app cHRM or gAMA here (because likely as not the
++ * application knows better than libpng what the correct values are.) Pass
++ * the info_ptr color_type field to png_colorspace_set_ICC because in the
++ * write case it has not yet been stored in png_ptr.
++ */
++ {
++ int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name,
++ proflen, profile, info_ptr->color_type);
++
++ png_colorspace_sync_info(png_ptr, info_ptr);
++
++ /* Don't do any of the copying if the profile was bad, or inconsistent. */
++ if (result == 0)
++ return;
++
++ /* But do write the gAMA and cHRM chunks from the profile. */
++ info_ptr->colorspace.flags |=
++ PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;
++ }
++
++ length = strlen(name)+1;
++ new_iccp_name = png_voidcast(png_charp, png_malloc_warn(png_ptr, length));
+
+ if (new_iccp_name == NULL)
+ {
+- png_warning(png_ptr, "Insufficient memory to process iCCP chunk");
++ png_benign_error(png_ptr, "Insufficient memory to process iCCP chunk");
+ return;
+ }
+
+- png_memcpy(new_iccp_name, name, length);
+- new_iccp_profile = (png_bytep)png_malloc_warn(png_ptr, proflen);
++ memcpy(new_iccp_name, name, length);
++ new_iccp_profile = png_voidcast(png_bytep,
++ png_malloc_warn(png_ptr, proflen));
+
+ if (new_iccp_profile == NULL)
+ {
+- png_free (png_ptr, new_iccp_name);
+- png_warning(png_ptr,
++ png_free(png_ptr, new_iccp_name);
++ new_iccp_name = NULL;
++ png_benign_error(png_ptr,
+ "Insufficient memory to process iCCP profile");
+ return;
+ }
+
+- png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
++ memcpy(new_iccp_profile, profile, proflen);
+
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
+
+ info_ptr->iccp_proflen = proflen;
+ info_ptr->iccp_name = new_iccp_name;
+ info_ptr->iccp_profile = new_iccp_profile;
+- /* Compression is always zero but is here so the API and info structure
+- * does not have to change if we introduce multiple compression types
+- */
+- info_ptr->iccp_compression = (png_byte)compression_type;
+ info_ptr->free_me |= PNG_FREE_ICCP;
+ info_ptr->valid |= PNG_INFO_iCCP;
+ }
+@@ -654,74 +713,81 @@
+
+ #ifdef PNG_TEXT_SUPPORTED
+ void PNGAPI
+-png_set_text(png_structp png_ptr, png_infop info_ptr, png_const_textp text_ptr,
+- int num_text)
++png_set_text(png_const_structrp png_ptr, png_inforp info_ptr,
++ png_const_textp text_ptr, int num_text)
+ {
+ int ret;
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
+
+- if (ret)
++ if (ret != 0)
+ png_error(png_ptr, "Insufficient memory to store text");
+ }
+
+ int /* PRIVATE */
+-png_set_text_2(png_structp png_ptr, png_infop info_ptr,
++png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
+ png_const_textp text_ptr, int num_text)
+ {
+ int i;
+
+- png_debug1(1, "in %s storage function", ((png_ptr == NULL ||
+- png_ptr->chunk_name[0] == '\0') ?
+- "text" : (png_const_charp)png_ptr->chunk_name));
++ 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)
+ {
+- if (info_ptr->text != NULL)
++ int old_num_text = info_ptr->num_text;
++ int max_text;
++ png_textp new_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;
+- int old_max;
++ max_text += num_text;
+
+- old_max = info_ptr->max_text;
+- info_ptr->max_text = info_ptr->num_text + num_text + 8;
+- old_text = info_ptr->text;
+- info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
+- (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
++ /* Round up to a multiple of 8 */
++ if (max_text < INT_MAX-8)
++ max_text = (max_text + 8) & ~0x7;
+
+- if (info_ptr->text == NULL)
+- {
+- png_free(png_ptr, old_text);
+- return(1);
+- }
++ else
++ max_text = INT_MAX;
+
+- png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
+- png_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 * png_sizeof(png_text)));
+- if (info_ptr->text == NULL)
+- 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)
+@@ -730,11 +796,12 @@
+ 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;
+ }
+
+- key_len = png_strlen(text_ptr[i].key);
++ key_len = strlen(text_ptr[i].key);
+
+ if (text_ptr[i].compression <= 0)
+ {
+@@ -748,20 +815,21 @@
+ /* Set iTXt data */
+
+ if (text_ptr[i].lang != NULL)
+- lang_len = png_strlen(text_ptr[i].lang);
++ lang_len = strlen(text_ptr[i].lang);
+
+ else
+ lang_len = 0;
+
+ if (text_ptr[i].lang_key != NULL)
+- lang_key_len = png_strlen(text_ptr[i].lang_key);
++ lang_key_len = strlen(text_ptr[i].lang_key);
+
+ else
+ lang_key_len = 0;
+ }
+ # 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
+@@ -780,32 +848,35 @@
+
+ else
+ {
+- text_length = png_strlen(text_ptr[i].text);
++ text_length = strlen(text_ptr[i].text);
+ textp->compression = text_ptr[i].compression;
+ }
+
+- textp->key = (png_charp)png_malloc_warn(png_ptr,
+- (png_size_t)
+- (key_len + text_length + lang_len + lang_key_len + 4));
++ 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);
+
+- png_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)
+ {
+ textp->lang = textp->key + key_len + 1;
+- png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
++ memcpy(textp->lang, text_ptr[i].lang, lang_len);
+ *(textp->lang + lang_len) = '\0';
+ textp->lang_key = textp->lang + lang_len + 1;
+- png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
++ memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
+ *(textp->lang_key + lang_key_len) = '\0';
+ textp->text = textp->lang_key + lang_key_len + 1;
+ }
+@@ -817,9 +888,8 @@
+ textp->text = textp->key + key_len + 1;
+ }
+
+- if (text_length)
+- png_memcpy(textp->text, text_ptr[i].text,
+- (png_size_t)(text_length));
++ if (text_length != 0)
++ memcpy(textp->text, text_ptr[i].text, text_length);
+
+ *(textp->text + text_length) = '\0';
+
+@@ -840,28 +910,39 @@
+ info_ptr->num_text++;
+ png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
+ }
++
+ return(0);
+ }
+ #endif
+
+ #ifdef PNG_tIME_SUPPORTED
+ void PNGAPI
+-png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time)
++png_set_tIME(png_const_structrp png_ptr, png_inforp info_ptr,
++ png_const_timep mod_time)
+ {
+ png_debug1(1, "in %s storage function", "tIME");
+
+- if (png_ptr == NULL || info_ptr == NULL ||
+- (png_ptr->mode & PNG_WROTE_tIME))
++ if (png_ptr == NULL || info_ptr == NULL || mod_time == NULL ||
++ (png_ptr->mode & PNG_WROTE_tIME) != 0)
+ return;
+
+- png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
++ if (mod_time->month == 0 || mod_time->month > 12 ||
++ mod_time->day == 0 || mod_time->day > 31 ||
++ mod_time->hour > 23 || mod_time->minute > 59 ||
++ mod_time->second > 60)
++ {
++ png_warning(png_ptr, "Ignoring invalid time value");
++ return;
++ }
++
++ info_ptr->mod_time = *mod_time;
+ info_ptr->valid |= PNG_INFO_tIME;
+ }
+ #endif
+
+ #ifdef PNG_tRNS_SUPPORTED
+ void PNGAPI
+-png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
++png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr,
+ png_const_bytep trans_alpha, int num_trans, png_const_color_16p trans_color)
+ {
+ png_debug1(1, "in %s storage function", "tRNS");
+@@ -874,16 +955,20 @@
+ /* It may not actually be necessary to set png_ptr->trans_alpha here;
+ * we do it for backward compatibility with the way the png_handle_tRNS
+ * function used to do the allocation.
++ *
++ * 1.6.0: The above statement is incorrect; png_handle_tRNS effectively
++ * relies on png_set_tRNS storing the information in png_struct
++ * (otherwise it won't be there for the code in pngrtran.c).
+ */
+
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
+
+ /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
+- png_ptr->trans_alpha = info_ptr->trans_alpha =
+- (png_bytep)png_malloc(png_ptr, (png_size_t)PNG_MAX_PALETTE_LENGTH);
++ png_ptr->trans_alpha = info_ptr->trans_alpha = png_voidcast(png_bytep,
++ png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
+
+ if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
+- png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
++ memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
+ }
+
+ if (trans_color != NULL)
+@@ -891,16 +976,15 @@
+ int sample_max = (1 << info_ptr->bit_depth);
+
+ if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
+- (int)trans_color->gray > sample_max) ||
++ trans_color->gray > sample_max) ||
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
+- ((int)trans_color->red > sample_max ||
+- (int)trans_color->green > sample_max ||
+- (int)trans_color->blue > sample_max)))
++ (trans_color->red > sample_max ||
++ trans_color->green > sample_max ||
++ trans_color->blue > sample_max)))
+ png_warning(png_ptr,
+ "tRNS chunk has out-of-range samples for bit_depth");
+
+- png_memcpy(&(info_ptr->trans_color), trans_color,
+- png_sizeof(png_color_16));
++ info_ptr->trans_color = *trans_color;
+
+ if (num_trans == 0)
+ num_trans = 1;
+@@ -918,8 +1002,8 @@
+
+ #ifdef PNG_sPLT_SUPPORTED
+ void PNGAPI
+-png_set_sPLT(png_structp png_ptr,
+- png_infop info_ptr, png_const_sPLT_tp entries, int nentries)
++png_set_sPLT(png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)
+ /*
+ * entries - array of png_sPLT_t structures
+ * to be added to the list of palettes
+@@ -930,220 +1014,455 @@
+ */
+ {
+ png_sPLT_tp np;
+- int i;
+
+- if (png_ptr == NULL || info_ptr == NULL)
++ if (png_ptr == NULL || info_ptr == NULL || nentries <= 0 || entries == NULL)
+ return;
+
+- np = (png_sPLT_tp)png_malloc_warn(png_ptr,
+- (info_ptr->splt_palettes_num + nentries) *
+- (png_size_t)png_sizeof(png_sPLT_t));
++ /* 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;
+ }
+
+- png_memcpy(np, info_ptr->splt_palettes,
+- info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
++ png_free(png_ptr, info_ptr->splt_palettes);
++ info_ptr->splt_palettes = np;
++ info_ptr->free_me |= PNG_FREE_SPLT;
+
+- png_free(png_ptr, info_ptr->splt_palettes);
+- info_ptr->splt_palettes=NULL;
++ np += info_ptr->splt_palettes_num;
+
+- for (i = 0; i < nentries; i++)
++ do
+ {
+- png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
+- png_const_sPLT_tp from = entries + i;
+- png_uint_32 length;
++ png_size_t length;
+
+- length = png_strlen(from->name) + 1;
+- to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)length);
+-
+- if (to->name == NULL)
++ /* Skip invalid input entries */
++ if (entries->name == NULL || entries->entries == NULL)
+ {
+- png_warning(png_ptr,
+- "Out of memory while processing sPLT chunk");
++ /* 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;
+ }
+
+- png_memcpy(to->name, from->name, length);
+- to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
+- (png_size_t)(from->nentries * png_sizeof(png_sPLT_entry)));
++ np->depth = entries->depth;
+
+- if (to->entries == NULL)
++ /* In the event of out-of-memory just return - there's no point keeping
++ * on trying to add sPLT chunks.
++ */
++ length = strlen(entries->name) + 1;
++ np->name = png_voidcast(png_charp, png_malloc_base(png_ptr, length));
++
++ if (np->name == NULL)
++ break;
++
++ memcpy(np->name, entries->name, length);
++
++ /* 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");
+- png_free(png_ptr, to->name);
+- to->name = NULL;
+- continue;
++ png_free(png_ptr, np->name);
++ np->name = NULL;
++ break;
+ }
+
+- png_memcpy(to->entries, from->entries,
+- from->nentries * png_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));
+
+- 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);
++
++ if (nentries > 0)
++ png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR);
++}
++#endif /* sPLT */
++
++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
++static png_byte
++check_location(png_const_structrp png_ptr, int location)
++{
++ location &= (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT);
++
++ /* New in 1.6.0; copy the location and check it. This is an API
++ * change; previously the app had to use the
++ * png_set_unknown_chunk_location API below for each chunk.
++ */
++ if (location == 0 && (png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
++ {
++ /* Write struct, so unknown chunks come from the app */
++ png_app_warning(png_ptr,
++ "png_set_unknown_chunks now expects a valid location");
++ /* Use the old behavior */
++ location = (png_byte)(png_ptr->mode &
++ (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT));
+ }
+
+- info_ptr->splt_palettes = np;
+- info_ptr->splt_palettes_num += nentries;
+- info_ptr->valid |= PNG_INFO_sPLT;
+- info_ptr->free_me |= PNG_FREE_SPLT;
++ /* 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");
++
++ /* Now reduce the location to the top-most set bit by removing each least
++ * significant bit in turn.
++ */
++ while (location != (location & -location))
++ location &= ~(location & -location);
++
++ /* The cast is safe because 'location' is a bit mask and only the low four
++ * bits are significant.
++ */
++ return (png_byte)location;
+ }
+-#endif /* PNG_sPLT_SUPPORTED */
+
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+ void PNGAPI
+-png_set_unknown_chunks(png_structp png_ptr,
+- png_infop info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)
++png_set_unknown_chunks(png_const_structrp png_ptr,
++ png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)
+ {
+ png_unknown_chunkp np;
+- int i;
+
+- if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
++ if (png_ptr == NULL || info_ptr == NULL || num_unknowns <= 0 ||
++ unknowns == NULL)
+ return;
+
+- np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
+- (png_size_t)(info_ptr->unknown_chunks_num + num_unknowns) *
+- png_sizeof(png_unknown_chunk));
++ /* Check for the failure cases where support has been disabled at compile
++ * time. This code is hardly ever compiled - it's here because
++ * STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this
++ * code) but may be meaningless if the read or write handling of unknown
++ * chunks is not compiled in.
++ */
++# if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \
++ defined(PNG_READ_SUPPORTED)
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
++ {
++ png_app_error(png_ptr, "no unknown chunk support on read");
++ return;
++ }
++# endif
++# if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \
++ defined(PNG_WRITE_SUPPORTED)
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
++ {
++ png_app_error(png_ptr, "no unknown chunk support on write");
++ return;
++ }
++# endif
++
++ /* 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. Now png_chunk_report is used to provide behavior
++ * appropriate to read or write.
++ */
++ np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr,
++ info_ptr->unknown_chunks, info_ptr->unknown_chunks_num, num_unknowns,
++ sizeof *np));
+
+ if (np == NULL)
+ {
+- png_warning(png_ptr,
+- "Out of memory while processing unknown chunk");
++ png_chunk_report(png_ptr, "too many unknown chunks",
++ PNG_CHUNK_WRITE_ERROR);
+ return;
+ }
+
+- png_memcpy(np, info_ptr->unknown_chunks,
+- (png_size_t)info_ptr->unknown_chunks_num *
+- png_sizeof(png_unknown_chunk));
++ png_free(png_ptr, info_ptr->unknown_chunks);
++ info_ptr->unknown_chunks = np; /* safe because it is initialized */
++ info_ptr->free_me |= PNG_FREE_UNKN;
+
+- png_free(png_ptr, info_ptr->unknown_chunks);
+- info_ptr->unknown_chunks = NULL;
++ np += info_ptr->unknown_chunks_num;
+
+- for (i = 0; i < num_unknowns; i++)
++ /* Increment unknown_chunks_num each time round the loop to protect the
++ * just-allocated chunk data.
++ */
++ for (; num_unknowns > 0; --num_unknowns, ++unknowns)
+ {
+- png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
+- png_const_unknown_chunkp from = unknowns + i;
++ memcpy(np->name, unknowns->name, (sizeof np->name));
++ np->name[(sizeof np->name)-1] = '\0';
++ np->location = check_location(png_ptr, unknowns->location);
+
+- png_memcpy(to->name, from->name, png_sizeof(from->name));
+- to->name[png_sizeof(to->name)-1] = '\0';
+- to->size = from->size;
+-
+- /* Note our location in the read or write sequence */
+- to->location = (png_byte)(png_ptr->mode & 0xff);
+-
+- if (from->size == 0)
+- to->data=NULL;
++ if (unknowns->size == 0)
++ {
++ np->data = NULL;
++ np->size = 0;
++ }
+
+ else
+ {
+- to->data = (png_bytep)png_malloc_warn(png_ptr,
+- (png_size_t)from->size);
++ np->data = png_voidcast(png_bytep,
++ png_malloc_base(png_ptr, unknowns->size));
+
+- if (to->data == NULL)
++ if (np->data == NULL)
+ {
+- png_warning(png_ptr,
+- "Out of memory while processing unknown chunk");
+- to->size = 0;
++ png_chunk_report(png_ptr, "unknown chunk: out of memory",
++ PNG_CHUNK_WRITE_ERROR);
++ /* But just skip storing the unknown chunk */
++ continue;
+ }
+
+- else
+- png_memcpy(to->data, from->data, from->size);
++ 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);
+ }
+-
+- info_ptr->unknown_chunks = np;
+- info_ptr->unknown_chunks_num += num_unknowns;
+- info_ptr->free_me |= PNG_FREE_UNKN;
+ }
+
+ void PNGAPI
+-png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
++png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr,
+ int chunk, int location)
+ {
+- if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
+- info_ptr->unknown_chunks_num)
+- info_ptr->unknown_chunks[chunk].location = (png_byte)location;
++ /* This API is pretty pointless in 1.6.0 because the location can be set
++ * before the call to png_set_unknown_chunks.
++ *
++ * TODO: add a png_app_warning in 1.7
++ */
++ if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 &&
++ chunk < info_ptr->unknown_chunks_num)
++ {
++ if ((location & (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT)) == 0)
++ {
++ png_app_error(png_ptr, "invalid unknown chunk location");
++ /* Fake out the pre 1.6.0 behavior: */
++ if ((location & PNG_HAVE_IDAT) != 0) /* undocumented! */
++ location = PNG_AFTER_IDAT;
++
++ else
++ location = PNG_HAVE_IHDR; /* also undocumented */
++ }
++
++ info_ptr->unknown_chunks[chunk].location =
++ check_location(png_ptr, location);
++ }
+ }
+ #endif
+
+
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+ png_uint_32 PNGAPI
+-png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
++png_permit_mng_features (png_structrp png_ptr, png_uint_32 mng_features)
+ {
+ png_debug(1, "in png_permit_mng_features");
+
+ if (png_ptr == NULL)
+- return (png_uint_32)0;
++ return 0;
+
+- png_ptr->mng_features_permitted =
+- (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
++ png_ptr->mng_features_permitted = mng_features & PNG_ALL_MNG_FEATURES;
+
+- return (png_uint_32)png_ptr->mng_features_permitted;
++ return png_ptr->mng_features_permitted;
+ }
+ #endif
+
+ #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
++static unsigned int
++add_one_chunk(png_bytep list, unsigned int count, png_const_bytep add, int keep)
++{
++ unsigned int i;
++
++ /* Utility function: update the 'keep' state of a chunk if it is already in
++ * the list, otherwise add it to the list.
++ */
++ for (i=0; i<count; ++i, list += 5)
++ {
++ if (memcmp(list, add, 4) == 0)
++ {
++ list[4] = (png_byte)keep;
++ return count;
++ }
++ }
++
++ if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT)
++ {
++ ++count;
++ memcpy(list, add, 4);
++ list[4] = (png_byte)keep;
++ }
++
++ return count;
++}
++
+ void PNGAPI
+-png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_const_bytep
+- chunk_list, int num_chunks)
++png_set_keep_unknown_chunks(png_structrp png_ptr, int keep,
++ png_const_bytep chunk_list, int num_chunks_in)
+ {
+- png_bytep new_list, p;
+- int i, old_num_chunks;
++ png_bytep new_list;
++ unsigned int num_chunks, old_num_chunks;
++
+ if (png_ptr == NULL)
+ return;
+
+- if (num_chunks == 0)
++ if (keep < 0 || keep >= PNG_HANDLE_CHUNK_LAST)
+ {
+- if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
+- png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+-
+- else
+- png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+-
+- if (keep == PNG_HANDLE_CHUNK_ALWAYS)
+- png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+-
+- else
+- png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+-
++ png_app_error(png_ptr, "png_set_keep_unknown_chunks: invalid keep");
+ return;
+ }
+
+- if (chunk_list == NULL)
+- return;
++ if (num_chunks_in <= 0)
++ {
++ png_ptr->unknown_default = keep;
++
++ /* '0' means just set the flags, so stop here */
++ if (num_chunks_in == 0)
++ return;
++ }
++
++ if (num_chunks_in < 0)
++ {
++ /* Ignore all unknown chunks and all chunks recognized by
++ * libpng except for IHDR, PLTE, tRNS, IDAT, and IEND
++ */
++ static PNG_CONST png_byte chunks_to_ignore[] = {
++ 98, 75, 71, 68, '\0', /* bKGD */
++ 99, 72, 82, 77, '\0', /* cHRM */
++ 103, 65, 77, 65, '\0', /* gAMA */
++ 104, 73, 83, 84, '\0', /* hIST */
++ 105, 67, 67, 80, '\0', /* iCCP */
++ 105, 84, 88, 116, '\0', /* iTXt */
++ 111, 70, 70, 115, '\0', /* oFFs */
++ 112, 67, 65, 76, '\0', /* pCAL */
++ 112, 72, 89, 115, '\0', /* pHYs */
++ 115, 66, 73, 84, '\0', /* sBIT */
++ 115, 67, 65, 76, '\0', /* sCAL */
++ 115, 80, 76, 84, '\0', /* sPLT */
++ 115, 84, 69, 82, '\0', /* sTER */
++ 115, 82, 71, 66, '\0', /* sRGB */
++ 116, 69, 88, 116, '\0', /* tEXt */
++ 116, 73, 77, 69, '\0', /* tIME */
++ 122, 84, 88, 116, '\0' /* zTXt */
++ };
++
++ chunk_list = chunks_to_ignore;
++ num_chunks = (unsigned int)/*SAFE*/(sizeof chunks_to_ignore)/5U;
++ }
++
++ else /* num_chunks_in > 0 */
++ {
++ if (chunk_list == NULL)
++ {
++ /* Prior to 1.6.0 this was silently ignored, now it is an app_error
++ * which can be switched off.
++ */
++ png_app_error(png_ptr, "png_set_keep_unknown_chunks: no chunk list");
++ return;
++ }
++
++ num_chunks = num_chunks_in;
++ }
+
+ old_num_chunks = png_ptr->num_chunk_list;
+- new_list=(png_bytep)png_malloc(png_ptr,
+- (png_size_t)(5*(num_chunks + old_num_chunks)));
++ if (png_ptr->chunk_list == NULL)
++ old_num_chunks = 0;
+
+- if (png_ptr->chunk_list != NULL)
++ /* Since num_chunks is always restricted to UINT_MAX/5 this can't overflow.
++ */
++ if (num_chunks + old_num_chunks > UINT_MAX/5)
+ {
+- png_memcpy(new_list, png_ptr->chunk_list,
+- (png_size_t)(5*old_num_chunks));
+- png_free(png_ptr, png_ptr->chunk_list);
+- png_ptr->chunk_list=NULL;
++ png_app_error(png_ptr, "png_set_keep_unknown_chunks: too many chunks");
++ return;
+ }
+
+- png_memcpy(new_list + 5*old_num_chunks, chunk_list,
+- (png_size_t)(5*num_chunks));
++ /* If these chunks are being reset to the default then no more memory is
++ * required because add_one_chunk above doesn't extend the list if the 'keep'
++ * parameter is the default.
++ */
++ if (keep != 0)
++ {
++ new_list = png_voidcast(png_bytep, png_malloc(png_ptr,
++ 5 * (num_chunks + old_num_chunks)));
+
+- for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
+- *p=(png_byte)keep;
++ if (old_num_chunks > 0)
++ memcpy(new_list, png_ptr->chunk_list, 5*old_num_chunks);
++ }
+
+- png_ptr->num_chunk_list = old_num_chunks + num_chunks;
+- png_ptr->chunk_list = new_list;
+- png_ptr->free_me |= PNG_FREE_LIST;
++ else if (old_num_chunks > 0)
++ new_list = png_ptr->chunk_list;
++
++ else
++ new_list = NULL;
++
++ /* Add the new chunks together with each one's handling code. If the chunk
++ * already exists the code is updated, otherwise the chunk is added to the
++ * end. (In libpng 1.6.0 order no longer matters because this code enforces
++ * the earlier convention that the last setting is the one that is used.)
++ */
++ if (new_list != NULL)
++ {
++ png_const_bytep inlist;
++ png_bytep outlist;
++ unsigned int i;
++
++ for (i=0; i<num_chunks; ++i)
++ {
++ old_num_chunks = add_one_chunk(new_list, old_num_chunks,
++ chunk_list+5*i, keep);
++ }
++
++ /* Now remove any spurious 'default' entries. */
++ num_chunks = 0;
++ for (i=0, inlist=outlist=new_list; i<old_num_chunks; ++i, inlist += 5)
++ {
++ if (inlist[4])
++ {
++ if (outlist != inlist)
++ memcpy(outlist, inlist, 5);
++ outlist += 5;
++ ++num_chunks;
++ }
++ }
++
++ /* This means the application has removed all the specialized handling. */
++ if (num_chunks == 0)
++ {
++ if (png_ptr->chunk_list != new_list)
++ png_free(png_ptr, new_list);
++
++ new_list = NULL;
++ }
++ }
++
++ else
++ num_chunks = 0;
++
++ png_ptr->num_chunk_list = num_chunks;
++
++ if (png_ptr->chunk_list != new_list)
++ {
++ if (png_ptr->chunk_list != NULL)
++ png_free(png_ptr, png_ptr->chunk_list);
++
++ png_ptr->chunk_list = new_list;
++ }
+ }
+ #endif
+
+ #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+ void PNGAPI
+-png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
++png_set_read_user_chunk_fn(png_structrp png_ptr, png_voidp user_chunk_ptr,
+ png_user_chunk_ptr read_user_chunk_fn)
+ {
+ png_debug(1, "in png_set_read_user_chunk_fn");
+@@ -1158,64 +1477,90 @@
+
+ #ifdef PNG_INFO_IMAGE_SUPPORTED
+ void PNGAPI
+-png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
++png_set_rows(png_const_structrp png_ptr, png_inforp info_ptr,
++ png_bytepp row_pointers)
+ {
+ png_debug1(1, "in %s storage function", "rows");
+
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+- if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
++ if (info_ptr->row_pointers != NULL &&
++ (info_ptr->row_pointers != row_pointers))
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
+
+ info_ptr->row_pointers = row_pointers;
+
+- if (row_pointers)
++ if (row_pointers != NULL)
+ info_ptr->valid |= PNG_INFO_IDAT;
+ }
+ #endif
+
+ void PNGAPI
+-png_set_compression_buffer_size(png_structp png_ptr, png_size_t size)
++png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size)
+ {
+ if (png_ptr == NULL)
+ return;
+
+- png_free(png_ptr, png_ptr->zbuf);
++ if (size == 0 || size > PNG_UINT_31_MAX)
++ png_error(png_ptr, "invalid compression buffer size");
+
+- if (size > ZLIB_IO_MAX)
+- {
+- png_warning(png_ptr, "Attempt to set buffer size beyond max ignored");
+- png_ptr->zbuf_size = ZLIB_IO_MAX;
+- size = ZLIB_IO_MAX; /* must fit */
+- }
++# ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
++ {
++ png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */
++ return;
++ }
++# endif
+
+- else
+- png_ptr->zbuf_size = (uInt)size;
++# ifdef PNG_WRITE_SUPPORTED
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
++ {
++ if (png_ptr->zowner != 0)
++ {
++ png_warning(png_ptr,
++ "Compression buffer size cannot be changed because it is in use");
++ return;
++ }
+
+- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
++ if (size > ZLIB_IO_MAX)
++ {
++ png_warning(png_ptr,
++ "Compression buffer size limited to system maximum");
++ size = ZLIB_IO_MAX; /* must fit */
++ }
+
+- /* The following ensures a relatively safe failure if this gets called while
+- * the buffer is actually in use.
+- */
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- png_ptr->zstream.avail_out = 0;
+- png_ptr->zstream.avail_in = 0;
++ else if (size < 6)
++ {
++ /* Deflate will potentially go into an infinite loop on a SYNC_FLUSH
++ * if this is permitted.
++ */
++ png_warning(png_ptr,
++ "Compression buffer size cannot be reduced below 6");
++ return;
++ }
++
++ if (png_ptr->zbuffer_size != size)
++ {
++ png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
++ png_ptr->zbuffer_size = (uInt)size;
++ }
++ }
++# endif
+ }
+
+ void PNGAPI
+-png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
++png_set_invalid(png_const_structrp png_ptr, png_inforp info_ptr, int mask)
+ {
+- if (png_ptr && info_ptr)
++ if (png_ptr != NULL && info_ptr != NULL)
+ info_ptr->valid &= ~mask;
+ }
+
+
+-
+ #ifdef PNG_SET_USER_LIMITS_SUPPORTED
+ /* This function was added to libpng 1.2.6 */
+ void PNGAPI
+-png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
++png_set_user_limits (png_structrp png_ptr, png_uint_32 user_width_max,
+ png_uint_32 user_height_max)
+ {
+ /* Images with dimensions larger than these limits will be
+@@ -1231,35 +1576,64 @@
+
+ /* This function was added to libpng 1.4.0 */
+ void PNGAPI
+-png_set_chunk_cache_max (png_structp png_ptr,
+- png_uint_32 user_chunk_cache_max)
++png_set_chunk_cache_max (png_structrp png_ptr, png_uint_32 user_chunk_cache_max)
+ {
+- if (png_ptr)
++ if (png_ptr != NULL)
+ png_ptr->user_chunk_cache_max = user_chunk_cache_max;
+ }
+
+ /* This function was added to libpng 1.4.1 */
+ void PNGAPI
+-png_set_chunk_malloc_max (png_structp png_ptr,
++png_set_chunk_malloc_max (png_structrp png_ptr,
+ png_alloc_size_t user_chunk_malloc_max)
+ {
+- if (png_ptr)
++ if (png_ptr != NULL)
+ png_ptr->user_chunk_malloc_max = user_chunk_malloc_max;
+ }
+-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
++#endif /* ?SET_USER_LIMITS */
+
+
+ #ifdef PNG_BENIGN_ERRORS_SUPPORTED
+ void PNGAPI
+-png_set_benign_errors(png_structp png_ptr, int allowed)
++png_set_benign_errors(png_structrp png_ptr, int allowed)
+ {
+ png_debug(1, "in png_set_benign_errors");
+
+- if (allowed)
+- png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
++ /* If allowed is 1, png_benign_error() is treated as a warning.
++ *
++ * If allowed is 0, png_benign_error() is treated as an error (which
++ * is the default behavior if png_set_benign_errors() is not called).
++ */
++
++ if (allowed != 0)
++ png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN |
++ PNG_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN;
+
+ else
+- png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;
++ png_ptr->flags &= ~(PNG_FLAG_BENIGN_ERRORS_WARN |
++ PNG_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN);
+ }
+-#endif /* PNG_BENIGN_ERRORS_SUPPORTED */
+-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
++#endif /* BENIGN_ERRORS */
++
++#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
++ /* 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 zeros
++ * (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)
++{
++ png_debug(1, "in png_set_check_for_invalid_index");
++
++ if (allowed > 0)
++ png_ptr->num_palette_max = 0;
++
++ else
++ png_ptr->num_palette_max = -1;
++}
++#endif
++#endif /* READ || WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pngstruct.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngstruct.h Thu Feb 05 13:00:26 2015 +0100
+@@ -29,11 +29,11 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Copyright (c) 1998-2011 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.)
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
++ * Last changed in libpng 1.6.1 [March 28, 2013]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+@@ -52,13 +52,130 @@
+ * in this structure and is required for decompressing the LZ compressed
+ * data in PNG files.
+ */
++#ifndef ZLIB_CONST
++ /* We must ensure that zlib uses 'const' in declarations. */
++# define ZLIB_CONST
++#endif
+ #include "zlib.h"
++#ifdef const
++ /* zlib.h sometimes #defines const to nothing, undo this. */
++# undef const
++#endif
++
++/* zlib.h has mediocre z_const use before 1.2.6, this stuff is for compatibility
++ * with older builds.
++ */
++#if ZLIB_VERNUM < 0x1260
++# define PNGZ_MSG_CAST(s) png_constcast(char*,s)
++# define PNGZ_INPUT_CAST(b) png_constcast(png_bytep,b)
++#else
++# define PNGZ_MSG_CAST(s) (s)
++# define PNGZ_INPUT_CAST(b) (b)
++#endif
++
++/* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib
++ * can handle at once. This type need be no larger than 16 bits (so maximum of
++ * 65535), this define allows us to discover how big it is, but limited by the
++ * maximuum for png_size_t. The value can be overriden in a library build
++ * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably
++ * lower value (e.g. 255 works). A lower value may help memory usage (slightly)
++ * and may even improve performance on some systems (and degrade it on others.)
++ */
++#ifndef ZLIB_IO_MAX
++# define ZLIB_IO_MAX ((uInt)-1)
++#endif
++
++#ifdef PNG_WRITE_SUPPORTED
++/* The type of a compression buffer list used by the write code. */
++typedef struct png_compression_buffer
++{
++ struct png_compression_buffer *next;
++ png_byte output[1]; /* actually zbuf_size */
++} png_compression_buffer, *png_compression_bufferp;
++
++#define PNG_COMPRESSION_BUFFER_SIZE(pp)\
++ (offsetof(png_compression_buffer, output) + (pp)->zbuffer_size)
++#endif
++
++/* Colorspace support; structures used in png_struct, png_info and in internal
++ * functions to hold and communicate information about the color space.
++ *
++ * PNG_COLORSPACE_SUPPORTED is only required if the application will perform
++ * colorspace corrections, otherwise all the colorspace information can be
++ * skipped and the size of libpng can be reduced (significantly) by compiling
++ * out the colorspace support.
++ */
++#ifdef PNG_COLORSPACE_SUPPORTED
++/* The chromaticities of the red, green and blue colorants and the chromaticity
++ * of the corresponding white point (i.e. of rgb(1.0,1.0,1.0)).
++ */
++typedef struct png_xy
++{
++ png_fixed_point redx, redy;
++ png_fixed_point greenx, greeny;
++ png_fixed_point bluex, bluey;
++ png_fixed_point whitex, whitey;
++} png_xy;
++
++/* The same data as above but encoded as CIE XYZ values. When this data comes
++ * from chromaticities the sum of the Y values is assumed to be 1.0
++ */
++typedef struct png_XYZ
++{
++ png_fixed_point red_X, red_Y, red_Z;
++ png_fixed_point green_X, green_Y, green_Z;
++ png_fixed_point blue_X, blue_Y, blue_Z;
++} png_XYZ;
++#endif /* COLORSPACE */
++
++#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
++/* A colorspace is all the above plus, potentially, profile information,
++ * however at present libpng does not use the profile internally so it is only
++ * stored in the png_info struct (if iCCP is supported.) The rendering intent
++ * is retained here and is checked.
++ *
++ * The file gamma encoding information is also stored here and gamma correction
++ * is done by libpng, whereas color correction must currently be done by the
++ * application.
++ */
++typedef struct png_colorspace
++{
++#ifdef PNG_GAMMA_SUPPORTED
++ png_fixed_point gamma; /* File gamma */
++#endif
++
++#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_16 rendering_intent; /* Rendering intent of a profile */
++#endif
++
++ /* Flags are always defined to simplify the code. */
++ png_uint_16 flags; /* As defined below */
++} png_colorspace, * PNG_RESTRICT png_colorspacerp;
++
++typedef const png_colorspace * PNG_RESTRICT png_const_colorspacerp;
++
++/* 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_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 */
+
+ struct png_struct_def
+ {
+ #ifdef PNG_SETJMP_SUPPORTED
+- jmp_buf longjmp_buffer; /* used in png_error */
++ jmp_buf jmp_buf_local; /* New name in 1.6.0 for jmp_buf in png_struct */
+ png_longjmp_ptr longjmp_fn;/* setjmp non-local goto function. */
++ jmp_buf *jmp_buf_ptr; /* passed to longjmp_fn */
++ size_t jmp_buf_size; /* size of the above, if allocated */
+ #endif
+ png_error_ptr error_fn; /* function for printing errors and aborting */
+ #ifdef PNG_WARNINGS_SUPPORTED
+@@ -91,22 +208,12 @@
+ png_uint_32 flags; /* flags indicating various things to libpng */
+ png_uint_32 transformations; /* which transformations to perform */
+
+- z_stream zstream; /* pointer to decompression structure (below) */
+- png_bytep zbuf; /* buffer for zlib */
+- uInt zbuf_size; /* size of zbuf (typically 65536) */
++ png_uint_32 zowner; /* ID (chunk type) of zstream owner, 0 if none */
++ z_stream zstream; /* decompression structure */
++
+ #ifdef PNG_WRITE_SUPPORTED
+-
+-/* Added in 1.5.4: state to keep track of whether the zstream has been
+- * initialized and if so whether it is for IDAT or some other chunk.
+- */
+-#define PNG_ZLIB_UNINITIALIZED 0
+-#define PNG_ZLIB_FOR_IDAT 1
+-#define PNG_ZLIB_FOR_TEXT 2 /* anything other than IDAT */
+-#define PNG_ZLIB_USE_MASK 3 /* bottom two bits */
+-#define PNG_ZLIB_IN_USE 4 /* a flag value */
+-
+- png_uint_32 zlib_state; /* State of zlib initialization */
+-/* End of material added at libpng 1.5.4 */
++ png_compression_bufferp zbuffer_list; /* Created on demand during write */
++ uInt zbuffer_size; /* size of the actual buffer */
+
+ int zlib_level; /* holds zlib compression level */
+ int zlib_method; /* holds zlib compression method */
+@@ -115,8 +222,7 @@
+ int zlib_strategy; /* holds zlib compression strategy */
+ #endif
+ /* Added at libpng 1.5.4 */
+-#if defined(PNG_WRITE_COMPRESSED_TEXT_SUPPORTED) || \
+- defined(PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED)
++#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+ int zlib_text_level; /* holds zlib compression level */
+ int zlib_text_method; /* holds zlib compression method */
+ int zlib_text_window_bits; /* holds zlib compression window bits */
+@@ -124,6 +230,14 @@
+ int zlib_text_strategy; /* holds zlib compression strategy */
+ #endif
+ /* End of material added at libpng 1.5.4 */
++/* Added at libpng 1.6.0 */
++#ifdef PNG_WRITE_SUPPORTED
++ int zlib_set_level; /* Actual values set into the zstream on write */
++ int zlib_set_method;
++ int zlib_set_window_bits;
++ int zlib_set_mem_level;
++ int zlib_set_strategy;
++#endif
+
+ png_uint_32 width; /* width of image in pixels */
+ png_uint_32 height; /* height of image in pixels */
+@@ -132,21 +246,32 @@
+ png_size_t rowbytes; /* size of row in bytes */
+ png_uint_32 iwidth; /* width of current interlaced row in pixels */
+ png_uint_32 row_number; /* current row in interlace pass */
+- png_bytep prev_row; /* buffer to save previous (unfiltered) row */
+- png_bytep row_buf; /* buffer to save current (unfiltered) row */
++ png_uint_32 chunk_name; /* PNG_CHUNK() id of current chunk */
++ png_bytep prev_row; /* buffer to save previous (unfiltered) row.
++ * This is a pointer into big_prev_row
++ */
++ png_bytep row_buf; /* buffer to save current (unfiltered) row.
++ * This is a pointer into big_row_buf
++ */
++#ifdef PNG_WRITE_SUPPORTED
+ png_bytep sub_row; /* buffer to save "sub" row when filtering */
+ png_bytep up_row; /* buffer to save "up" row when filtering */
+ png_bytep avg_row; /* buffer to save "avg" row when filtering */
+ png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */
+- png_row_info row_info; /* used for transformation routines */
++#endif
+ png_size_t info_rowbytes; /* Added in 1.5.4: cache of updated row bytes */
+
+ png_uint_32 idat_size; /* current IDAT size for read */
+ png_uint_32 crc; /* current chunk CRC value */
+ png_colorp palette; /* palette from the input file */
+ png_uint_16 num_palette; /* number of color entries in palette */
++
++/* Added at libpng-1.5.10 */
++#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
++ int num_palette_max; /* maximum palette index found in IDAT */
++#endif
++
+ png_uint_16 num_trans; /* number of transparency values */
+- png_byte chunk_name[5]; /* null-terminated name of current chunk */
+ png_byte compression; /* file compression type (always 0) */
+ png_byte filter; /* file filter type (always 0) */
+ png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
+@@ -154,12 +279,17 @@
+ png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */
+ png_byte color_type; /* color type of file */
+ png_byte bit_depth; /* bit depth of file */
+- png_byte usr_bit_depth; /* bit depth of users row */
++ png_byte usr_bit_depth; /* bit depth of users row: write only */
+ png_byte pixel_depth; /* number of bits per pixel */
+ png_byte channels; /* number of channels in file */
+- png_byte usr_channels; /* channels at start of write */
++#ifdef PNG_WRITE_SUPPORTED
++ png_byte usr_channels; /* channels at start of write: write only */
++#endif
+ png_byte sig_bytes; /* magic bytes read/written from start of file */
+-
++ png_byte maximum_pixel_depth;
++ /* pixel depth used for the row buffers */
++ png_byte transformed_pixel_depth;
++ /* pixel depth after read/write transforms */
+ #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+ png_uint_16 filler; /* filler bytes for pixel expansion */
+ #endif
+@@ -172,7 +302,7 @@
+ #ifdef PNG_READ_GAMMA_SUPPORTED
+ png_color_16 background_1; /* background normalized to gamma 1.0 */
+ #endif
+-#endif /* PNG_bKGD_SUPPORTED */
++#endif /* bKGD */
+
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+ png_flush_ptr output_flush_fn; /* Function for flushing output */
+@@ -180,19 +310,20 @@
+ png_uint_32 flush_rows; /* number of rows written since last flush */
+ #endif
+
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
++#ifdef PNG_READ_GAMMA_SUPPORTED
+ int gamma_shift; /* number of "insignificant" bits in 16-bit gamma */
+- png_fixed_point gamma; /* file gamma value */
+ png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */
+-#endif
+
+-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+ png_bytep gamma_table; /* gamma table for 8-bit depth files */
++ png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
++#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
++ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
++ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+ png_bytep gamma_from_1; /* converts from 1.0 to screen */
+ png_bytep gamma_to_1; /* converts from file to 1.0 */
+- png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
+ png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
+ png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
++#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
+ #endif
+
+ #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)
+@@ -228,14 +359,7 @@
+ int process_mode; /* what push library is currently doing */
+ int cur_palette; /* current push library palette index */
+
+-# ifdef PNG_TEXT_SUPPORTED
+- png_size_t current_text_size; /* current size of text input data */
+- png_size_t current_text_left; /* how much text left to read in input */
+- png_charp current_text; /* current text chunk buffer */
+- png_charp current_text_ptr; /* current location in current_text */
+-# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */
+-
+-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
++#endif /* PROGRESSIVE_READ */
+
+ #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+ /* For the Borland special 64K segment handler */
+@@ -251,10 +375,6 @@
+ png_bytep quantize_index; /* index translation for palette files */
+ #endif
+
+-#if defined(PNG_READ_QUANTIZE_SUPPORTED) || defined(PNG_hIST_SUPPORTED)
+- png_uint_16p hist; /* histogram */
+-#endif
+-
+ #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+ png_byte heuristic_method; /* heuristic for row filter selection */
+ png_byte num_prev_filters; /* number of weights for previous rows */
+@@ -265,9 +385,17 @@
+ png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */
+ #endif
+
++ /* Options */
++#ifdef PNG_SET_OPTION_SUPPORTED
++ png_byte options; /* On/off state (up to 4 options) */
++#endif
++
++#if PNG_LIBPNG_VER < 10700
++/* To do: remove this from libpng-1.7 */
+ #ifdef PNG_TIME_RFC1123_SUPPORTED
+ char time_buffer[29]; /* String to hold RFC 1123 time text */
+ #endif
++#endif
+
+ /* New members added in libpng-1.0.6 */
+
+@@ -275,27 +403,31 @@
+
+ #ifdef PNG_USER_CHUNKS_SUPPORTED
+ png_voidp user_chunk_ptr;
++#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+ png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */
+ #endif
++#endif
+
+-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- int num_chunk_list;
+- png_bytep chunk_list;
++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++ int unknown_default; /* As PNG_HANDLE_* */
++ unsigned int num_chunk_list; /* Number of entries in the list */
++ png_bytep chunk_list; /* List of png_byte[5]; the textual chunk name
++ * followed by a PNG_HANDLE_* byte */
+ #endif
+
+ /* New members added in libpng-1.0.3 */
+ #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+ png_byte rgb_to_gray_status;
++ /* Added in libpng 1.5.5 to record setting of coefficients: */
++ png_byte rgb_to_gray_coefficients_set;
+ /* These were changed from png_byte in libpng-1.0.6 */
+ png_uint_16 rgb_to_gray_red_coeff;
+ png_uint_16 rgb_to_gray_green_coeff;
+- png_uint_16 rgb_to_gray_blue_coeff;
++ /* deleted in 1.5.5: rgb_to_gray_blue_coeff; */
+ #endif
+
+ /* New member added in libpng-1.0.4 (renamed in 1.0.9) */
+-#if defined(PNG_MNG_FEATURES_SUPPORTED) || \
+- defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
+- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
++#if defined(PNG_MNG_FEATURES_SUPPORTED)
+ /* Changed from png_byte to png_uint_32 at version 1.2.0 */
+ png_uint_32 mng_features_permitted;
+ #endif
+@@ -345,21 +477,41 @@
+ #endif
+
+ /* New member added in libpng-1.0.25 and 1.2.17 */
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+- /* Storage for unknown chunk that the library doesn't recognize. */
++#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
++ /* Temporary storage for unknown chunk that the library doesn't recognize,
++ * used while reading the chunk.
++ */
+ png_unknown_chunk unknown_chunk;
+ #endif
+
+-/* New members added in libpng-1.2.26 */
++/* New member added in libpng-1.2.26 */
+ png_size_t old_big_row_buf_size;
+- png_size_t old_prev_row_size;
+
++#ifdef PNG_READ_SUPPORTED
+ /* New member added in libpng-1.2.30 */
+- png_charp chunkdata; /* buffer for reading chunk data */
++ png_bytep read_buffer; /* buffer for reading chunk data */
++ png_alloc_size_t read_buffer_size; /* current size of the buffer */
++#endif
++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
++ uInt IDAT_read_size; /* limit on read buffer size for IDAT */
++#endif
+
+ #ifdef PNG_IO_STATE_SUPPORTED
+ /* New member added in libpng-1.4.0 */
+ png_uint_32 io_state;
+ #endif
++
++/* New member added in libpng-1.5.6 */
++ png_bytep big_prev_row;
++
++/* New member added in libpng-1.5.7 */
++ void (*read_filter[PNG_FILTER_VALUE_LAST-1])(png_row_infop row_info,
++ png_bytep row, png_const_bytep prev_row);
++
++#ifdef PNG_READ_SUPPORTED
++#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
++ png_colorspace colorspace;
++#endif
++#endif
+ };
+ #endif /* PNGSTRUCT_H */
+--- ./jdk/src/share/native/sun/awt/libpng/pngtest.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngtest.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -61,16 +61,50 @@
+
+ #define _POSIX_SOURCE 1
+
+-#include "zlib.h"
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++/* Defined so I can write to a file on gui/windowing platforms */
++/* #define STDERR stderr */
++#define STDERR stdout /* For DOS */
++
+ #include "png.h"
++
++/* Known chunks that exist in pngtest.png must be supported or pngtest will fail
++ * simply as a result of re-ordering them. This may be fixed in 1.7
++ *
++ * pngtest allocates a single row buffer for each row and overwrites it,
++ * therefore if the write side doesn't support the writing of interlaced images
++ * nothing can be done for an interlaced image (and the code below will fail
++ * horribly trying to write extra data after writing garbage).
++ */
++#if defined PNG_READ_SUPPORTED && /* else nothing can be done */\
++ defined PNG_READ_bKGD_SUPPORTED &&\
++ defined PNG_READ_cHRM_SUPPORTED &&\
++ defined PNG_READ_gAMA_SUPPORTED &&\
++ defined PNG_READ_oFFs_SUPPORTED &&\
++ defined PNG_READ_pCAL_SUPPORTED &&\
++ defined PNG_READ_pHYs_SUPPORTED &&\
++ defined PNG_READ_sBIT_SUPPORTED &&\
++ defined PNG_READ_sCAL_SUPPORTED &&\
++ defined PNG_READ_sRGB_SUPPORTED &&\
++ defined PNG_READ_tEXt_SUPPORTED &&\
++ defined PNG_READ_tIME_SUPPORTED &&\
++ defined PNG_READ_zTXt_SUPPORTED &&\
++ defined PNG_WRITE_INTERLACING_SUPPORTED
++
++#ifdef PNG_ZLIB_HEADER
++# include PNG_ZLIB_HEADER /* defined by pnglibconf.h from 1.7 */
++#else
++# include "zlib.h"
++#endif
++
+ /* Copied from pngpriv.h but only used in error messages below. */
+ #ifndef PNG_ZBUF_SIZE
+ # define PNG_ZBUF_SIZE 8192
+ #endif
+-# include <stdio.h>
+-# include <stdlib.h>
+-# include <string.h>
+-# define FCLOSE(file) fclose(file)
++#define FCLOSE(file) fclose(file)
+
+ #ifndef PNG_STDIO_SUPPORTED
+ typedef FILE * png_FILE_p;
+@@ -95,17 +129,6 @@
+ # define SINGLE_ROWBUF_ALLOC /* Makes buffer overruns easier to nail */
+ #endif
+
+-/* The code uses memcmp and memcpy on large objects (typically row pointers) so
+- * it is necessary to do soemthing special on certain architectures, note that
+- * the actual support for this was effectively removed in 1.4, so only the
+- * memory remains in this program:
+- */
+-#define CVT_PTR(ptr) (ptr)
+-#define CVT_PTR_NOCHECK(ptr) (ptr)
+-#define png_memcmp memcmp
+-#define png_memcpy memcpy
+-#define png_memset memset
+-
+ /* Turn on CPU timing
+ #define PNGTEST_TIMING
+ */
+@@ -126,30 +149,34 @@
+ #endif
+
+ static int verbose = 0;
+-
+-int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));
+-
+-#ifdef __TURBOC__
+-#include <mem.h>
+-#endif
+-
+-/* Defined so I can write to a file on gui/windowing platforms */
+-/* #define STDERR stderr */
+-#define STDERR stdout /* For DOS */
++static int strict = 0;
++static int relaxed = 0;
++static int unsupported_chunks = 0; /* chunk unsupported by libpng in input */
++static int error_count = 0; /* count calls to png_error */
++static int warning_count = 0; /* count calls to png_warning */
+
+ /* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
+ #ifndef png_jmpbuf
+ # define png_jmpbuf(png_ptr) png_ptr->jmpbuf
+ #endif
+
++/* Defines for unknown chunk handling if required. */
++#ifndef PNG_HANDLE_CHUNK_ALWAYS
++# define PNG_HANDLE_CHUNK_ALWAYS 3
++#endif
++#ifndef PNG_HANDLE_CHUNK_IF_SAFE
++# define PNG_HANDLE_CHUNK_IF_SAFE 2
++#endif
++
++/* Utility to save typing/errors, the argument must be a name */
++#define MEMZERO(var) ((void)memset(&var, 0, sizeof var))
++
+ /* Example of using row callbacks to make a simple progress meter */
+ static int status_pass = 1;
+ static int status_dots_requested = 0;
+ static int status_dots = 1;
+
+-void PNGCBAPI
+-read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
+-void PNGCBAPI
++static void PNGCBAPI
+ read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
+ {
+ if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
+@@ -173,9 +200,8 @@
+ fprintf(stdout, "r");
+ }
+
+-void PNGCBAPI
+-write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
+-void PNGCBAPI
++#ifdef PNG_WRITE_SUPPORTED
++static void PNGCBAPI
+ write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
+ {
+ if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7)
+@@ -183,6 +209,7 @@
+
+ fprintf(stdout, "w");
+ }
++#endif
+
+
+ #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+@@ -191,9 +218,7 @@
+ * 5 in case illegal filter values are present.)
+ */
+ static png_uint_32 filters_used[256];
+-void PNGCBAPI
+-count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data);
+-void PNGCBAPI
++static void PNGCBAPI
+ count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
+ {
+ if (png_ptr != NULL && row_info != NULL)
+@@ -208,9 +233,7 @@
+
+ static png_uint_32 zero_samples;
+
+-void PNGCBAPI
+-count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data);
+-void PNGCBAPI
++static void PNGCBAPI
+ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
+ {
+ png_bytep dp = data;
+@@ -288,7 +311,8 @@
+ png_uint_32 n, nstop;
+ int channel;
+ int color_channels = row_info->channels;
+- if (row_info->color_type > 3)color_channels--;
++ if (row_info->color_type > 3)
++ color_channels--;
+
+ for (n = 0, nstop=row_info->width; n<nstop; n++)
+ {
+@@ -315,9 +339,7 @@
+ }
+ }
+ }
+-#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */
+-
+-static int wrote_question = 0;
++#endif /* WRITE_USER_TRANSFORM */
+
+ #ifndef PNG_STDIO_SUPPORTED
+ /* START of code to validate stdio-free compilation */
+@@ -366,12 +388,11 @@
+ default:
+ err = 1; /* uninitialized */
+ }
+- if (err)
++ if (err != 0)
+ png_error(png_ptr, "Bad I/O state or buffer size");
+ }
+ #endif
+
+-#ifndef USE_FAR_KEYWORD
+ static void PNGCBAPI
+ pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+ {
+@@ -396,59 +417,6 @@
+ pngtest_check_io_state(png_ptr, length, PNG_IO_READING);
+ #endif
+ }
+-#else
+-/* This is the model-independent version. Since the standard I/O library
+- can't handle far buffers in the medium and small models, we have to copy
+- the data.
+-*/
+-
+-#define NEAR_BUF_SIZE 1024
+-#define MIN(a,b) (a <= b ? a : b)
+-
+-static void PNGCBAPI
+-pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+-{
+- png_size_t check;
+- png_byte *n_data;
+- png_FILE_p io_ptr;
+-
+- /* Check if data really is near. If so, use usual code. */
+- n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+- io_ptr = (png_FILE_p)CVT_PTR(png_get_io_ptr(png_ptr));
+- if ((png_bytep)n_data == data)
+- {
+- check = fread(n_data, 1, length, io_ptr);
+- }
+- else
+- {
+- png_byte buf[NEAR_BUF_SIZE];
+- png_size_t read, remaining, err;
+- check = 0;
+- remaining = length;
+-
+- do
+- {
+- read = MIN(NEAR_BUF_SIZE, remaining);
+- err = fread(buf, 1, 1, io_ptr);
+- png_memcpy(data, buf, read); /* Copy far buffer to near buffer */
+- if (err != read)
+- break;
+- else
+- check += err;
+- data += read;
+- remaining -= read;
+- }
+- while (remaining != 0);
+- }
+-
+- if (check != length)
+- png_error(png_ptr, "Read Error");
+-
+-#ifdef PNG_IO_STATE_SUPPORTED
+- pngtest_check_io_state(png_ptr, length, PNG_IO_READING);
+-#endif
+-}
+-#endif /* USE_FAR_KEYWORD */
+
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+ static void PNGCBAPI
+@@ -464,7 +432,6 @@
+ * write_data function and use it at run time with png_set_write_fn(), rather
+ * than changing the library.
+ */
+-#ifndef USE_FAR_KEYWORD
+ static void PNGCBAPI
+ pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+ {
+@@ -481,81 +448,31 @@
+ pngtest_check_io_state(png_ptr, length, PNG_IO_WRITING);
+ #endif
+ }
+-#else
+-/* This is the model-independent version. Since the standard I/O library
+- can't handle far buffers in the medium and small models, we have to copy
+- the data.
+-*/
+-
+-#define NEAR_BUF_SIZE 1024
+-#define MIN(a,b) (a <= b ? a : b)
+-
+-static void PNGCBAPI
+-pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+-{
+- png_size_t check;
+- png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */
+- png_FILE_p io_ptr;
+-
+- /* Check if data really is near. If so, use usual code. */
+- near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+- io_ptr = (png_FILE_p)CVT_PTR(png_get_io_ptr(png_ptr));
+-
+- if ((png_bytep)near_data == data)
+- {
+- check = fwrite(near_data, 1, length, io_ptr);
+- }
+-
+- else
+- {
+- png_byte buf[NEAR_BUF_SIZE];
+- png_size_t written, remaining, err;
+- check = 0;
+- remaining = length;
+-
+- do
+- {
+- written = MIN(NEAR_BUF_SIZE, remaining);
+- png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
+- err = fwrite(buf, 1, written, io_ptr);
+- if (err != written)
+- break;
+- else
+- check += err;
+- data += written;
+- remaining -= written;
+- }
+- while (remaining != 0);
+- }
+-
+- if (check != length)
+- {
+- png_error(png_ptr, "Write Error");
+- }
+-
+-#ifdef PNG_IO_STATE_SUPPORTED
+- pngtest_check_io_state(png_ptr, length, PNG_IO_WRITING);
+-#endif
+-}
+-#endif /* USE_FAR_KEYWORD */
++#endif /* !STDIO */
+
+ /* This function is called when there is a warning, but the library thinks
+ * it can continue anyway. Replacement functions don't have to do anything
+ * here if you don't want to. In the default configuration, png_ptr is
+ * not used, but it is passed in case it may be useful.
+ */
++typedef struct
++{
++ PNG_CONST char *file_name;
++} pngtest_error_parameters;
++
+ static void PNGCBAPI
+ pngtest_warning(png_structp png_ptr, png_const_charp message)
+ {
+ PNG_CONST char *name = "UNKNOWN (ERROR!)";
+- char *test;
+- test = png_get_error_ptr(png_ptr);
++ pngtest_error_parameters *test =
++ (pngtest_error_parameters*)png_get_error_ptr(png_ptr);
+
+- if (test == NULL)
+- fprintf(STDERR, "%s: libpng warning: %s\n", name, message);
++ ++warning_count;
+
+- else
+- fprintf(STDERR, "%s: libpng warning: %s\n", test, message);
++ if (test != NULL && test->file_name != NULL)
++ name = test->file_name;
++
++ fprintf(STDERR, "%s: libpng warning: %s\n", name, message);
+ }
+
+ /* This is the default error handling function. Note that replacements for
+@@ -566,12 +483,14 @@
+ static void PNGCBAPI
+ pngtest_error(png_structp png_ptr, png_const_charp message)
+ {
++ ++error_count;
++
+ pngtest_warning(png_ptr, message);
+ /* We can return because png_error calls the default handler, which is
+ * actually OK in this case.
+ */
+ }
+-#endif /* !PNG_STDIO_SUPPORTED */
++
+ /* END of code to validate stdio-free compilation */
+
+ /* START of code to validate memory allocation and deallocation */
+@@ -590,9 +509,9 @@
+ {
+ png_alloc_size_t size;
+ png_voidp pointer;
+- struct memory_information FAR *next;
++ struct memory_information *next;
+ } memory_information;
+-typedef memory_information FAR *memory_infop;
++typedef memory_information *memory_infop;
+
+ static memory_infop pinformation = NULL;
+ static int current_allocation = 0;
+@@ -622,7 +541,7 @@
+ memory_infop pinfo;
+ png_set_mem_fn(png_ptr, NULL, NULL, NULL);
+ pinfo = (memory_infop)png_malloc(png_ptr,
+- png_sizeof(*pinfo));
++ (sizeof *pinfo));
+ pinfo->size = size;
+ current_allocation += size;
+ total_allocation += size;
+@@ -648,9 +567,9 @@
+ pinfo->next = pinformation;
+ pinformation = pinfo;
+ /* Make sure the caller isn't assuming zeroed memory. */
+- png_memset(pinfo->pointer, 0xdd, pinfo->size);
++ memset(pinfo->pointer, 0xdd, pinfo->size);
+
+- if (verbose)
++ if (verbose != 0)
+ printf("png_malloc %lu bytes at %p\n", (unsigned long)size,
+ pinfo->pointer);
+
+@@ -675,7 +594,7 @@
+
+ /* Unlink the element from the list. */
+ {
+- memory_infop FAR *ppinfo = &pinformation;
++ memory_infop *ppinfo = &pinformation;
+
+ for (;;)
+ {
+@@ -689,15 +608,16 @@
+ fprintf(STDERR, "Duplicate free of memory\n");
+ /* We must free the list element too, but first kill
+ the memory that is to be freed. */
+- png_memset(ptr, 0x55, pinfo->size);
+- png_free_default(png_ptr, pinfo);
++ memset(ptr, 0x55, pinfo->size);
++ if (pinfo != NULL)
++ free(pinfo);
+ pinfo = NULL;
+ break;
+ }
+
+ if (pinfo->next == NULL)
+ {
+- fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);
++ fprintf(STDERR, "Pointer %p not found\n", ptr);
+ break;
+ }
+
+@@ -706,35 +626,84 @@
+ }
+
+ /* Finally free the data. */
+- if (verbose)
++ if (verbose != 0)
+ printf("Freeing %p\n", ptr);
+
+- png_free_default(png_ptr, ptr);
++ if (ptr != NULL)
++ free(ptr);
+ ptr = NULL;
+ }
+-#endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */
++#endif /* USER_MEM && DEBUG */
+ /* END of code to test memory allocation/deallocation */
+
+
++#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+ /* Demonstration of user chunk support of the sTER and vpAg chunks */
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+
+ /* (sTER is a public chunk not yet known by libpng. vpAg is a private
+ chunk used in ImageMagick to store "virtual page" size). */
+
+-static png_uint_32 user_chunk_data[4];
++static struct user_chunk_data
++{
++ png_const_infop info_ptr;
++ png_uint_32 vpAg_width, vpAg_height;
++ png_byte vpAg_units;
++ png_byte sTER_mode;
++ int location[2];
++}
++user_chunk_data;
+
+- /* 0: sTER mode + 1
+- * 1: vpAg width
+- * 2: vpAg height
+- * 3: vpAg units
+- */
++/* Used for location and order; zero means nothing. */
++#define have_sTER 0x01
++#define have_vpAg 0x02
++#define before_PLTE 0x10
++#define before_IDAT 0x20
++#define after_IDAT 0x40
+
+-static int PNGCBAPI read_user_chunk_callback(png_struct *png_ptr,
+- png_unknown_chunkp chunk)
++static void
++init_callback_info(png_const_infop info_ptr)
+ {
+- png_uint_32
+- *my_user_chunk_data;
++ MEMZERO(user_chunk_data);
++ user_chunk_data.info_ptr = info_ptr;
++}
++
++static int
++set_location(png_structp png_ptr, struct user_chunk_data *data, int what)
++{
++ int location;
++
++ if ((data->location[0] & what) != 0 || (data->location[1] & what) != 0)
++ return 0; /* already have one of these */
++
++ /* Find where we are (the code below zeroes info_ptr to indicate that the
++ * chunks before the first IDAT have been read.)
++ */
++ if (data->info_ptr == NULL) /* after IDAT */
++ location = what | after_IDAT;
++
++ else if (png_get_valid(png_ptr, data->info_ptr, PNG_INFO_PLTE) != 0)
++ location = what | before_IDAT;
++
++ else
++ location = what | before_PLTE;
++
++ if (data->location[0] == 0)
++ data->location[0] = location;
++
++ else
++ data->location[1] = location;
++
++ return 1; /* handled */
++}
++
++static int PNGCBAPI
++read_user_chunk_callback(png_struct *png_ptr, png_unknown_chunkp chunk)
++{
++ struct user_chunk_data *my_user_chunk_data =
++ (struct user_chunk_data*)png_get_user_chunk_ptr(png_ptr);
++
++ if (my_user_chunk_data == NULL)
++ png_error(png_ptr, "lost user chunk pointer");
+
+ /* Return one of the following:
+ * return (-n); chunk had an error
+@@ -759,9 +728,14 @@
+ if (chunk->data[0] != 0 && chunk->data[0] != 1)
+ return (-1); /* Invalid mode */
+
+- my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
+- my_user_chunk_data[0]=chunk->data[0]+1;
+- return (1);
++ if (set_location(png_ptr, my_user_chunk_data, have_sTER) != 0)
++ {
++ my_user_chunk_data->sTER_mode=chunk->data[0];
++ return (1);
++ }
++
++ else
++ return (0); /* duplicate sTER - give it to libpng */
+ }
+
+ if (chunk->name[0] != 118 || chunk->name[1] != 112 || /* v p */
+@@ -773,30 +747,126 @@
+ if (chunk->size != 9)
+ return (-1); /* Error return */
+
+- my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
++ if (set_location(png_ptr, my_user_chunk_data, have_vpAg) == 0)
++ return (0); /* duplicate vpAg */
+
+- my_user_chunk_data[1]=png_get_uint_31(png_ptr, chunk->data);
+- my_user_chunk_data[2]=png_get_uint_31(png_ptr, chunk->data + 4);
+- my_user_chunk_data[3]=(png_uint_32)chunk->data[8];
++ my_user_chunk_data->vpAg_width = png_get_uint_31(png_ptr, chunk->data);
++ my_user_chunk_data->vpAg_height = png_get_uint_31(png_ptr, chunk->data + 4);
++ my_user_chunk_data->vpAg_units = chunk->data[8];
+
+ return (1);
++}
+
++#ifdef PNG_WRITE_SUPPORTED
++static void
++write_sTER_chunk(png_structp write_ptr)
++{
++ png_byte sTER[5] = {115, 84, 69, 82, '\0'};
++
++ if (verbose != 0)
++ fprintf(STDERR, "\n stereo mode = %d\n", user_chunk_data.sTER_mode);
++
++ png_write_chunk(write_ptr, sTER, &user_chunk_data.sTER_mode, 1);
+ }
++
++static void
++write_vpAg_chunk(png_structp write_ptr)
++{
++ png_byte vpAg[5] = {118, 112, 65, 103, '\0'};
++
++ png_byte vpag_chunk_data[9];
++
++ if (verbose != 0)
++ fprintf(STDERR, " vpAg = %lu x %lu, units = %d\n",
++ (unsigned long)user_chunk_data.vpAg_width,
++ (unsigned long)user_chunk_data.vpAg_height,
++ user_chunk_data.vpAg_units);
++
++ png_save_uint_32(vpag_chunk_data, user_chunk_data.vpAg_width);
++ png_save_uint_32(vpag_chunk_data + 4, user_chunk_data.vpAg_height);
++ vpag_chunk_data[8] = user_chunk_data.vpAg_units;
++ png_write_chunk(write_ptr, vpAg, vpag_chunk_data, 9);
++}
++
++static void
++write_chunks(png_structp write_ptr, int location)
++{
++ int i;
++
++ /* Notice that this preserves the original chunk order, however chunks
++ * intercepted by the callback will be written *after* chunks passed to
++ * libpng. This will actually reverse a pair of sTER chunks or a pair of
++ * vpAg chunks, resulting in an error later. This is not worth worrying
++ * about - the chunks should not be duplicated!
++ */
++ for (i=0; i<2; ++i)
++ {
++ if (user_chunk_data.location[i] == (location | have_sTER))
++ write_sTER_chunk(write_ptr);
++
++ else if (user_chunk_data.location[i] == (location | have_vpAg))
++ write_vpAg_chunk(write_ptr);
++ }
++}
++#endif /* WRITE */
++#else /* !READ_USER_CHUNKS */
++# define write_chunks(pp,loc) ((void)0)
+ #endif
+ /* END of code to demonstrate user chunk support */
+
++/* START of code to check that libpng has the required text support; this only
++ * checks for the write support because if read support is missing the chunk
++ * will simply not be reported back to pngtest.
++ */
++#ifdef PNG_TEXT_SUPPORTED
++static void
++pngtest_check_text_support(png_const_structp png_ptr, png_textp text_ptr,
++ int num_text)
++{
++ while (num_text > 0)
++ {
++ switch (text_ptr[--num_text].compression)
++ {
++ case PNG_TEXT_COMPRESSION_NONE:
++ break;
++
++ case PNG_TEXT_COMPRESSION_zTXt:
++# ifndef PNG_WRITE_zTXt_SUPPORTED
++ ++unsupported_chunks;
++# endif
++ break;
++
++ case PNG_ITXT_COMPRESSION_NONE:
++ case PNG_ITXT_COMPRESSION_zTXt:
++# ifndef PNG_WRITE_iTXt_SUPPORTED
++ ++unsupported_chunks;
++# endif
++ break;
++
++ default:
++ /* This is an error */
++ png_error(png_ptr, "invalid text chunk compression field");
++ break;
++ }
++ }
++}
++#endif
++/* END of code to check that libpng has the required text support */
++
+ /* Test one file */
+-int
++static int
+ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
+ {
+ static png_FILE_p fpin;
+ static png_FILE_p fpout; /* "static" prevents setjmp corruption */
++ pngtest_error_parameters error_parameters;
+ png_structp read_ptr;
+ png_infop read_info_ptr, end_info_ptr;
+ #ifdef PNG_WRITE_SUPPORTED
+ png_structp write_ptr;
+ png_infop write_info_ptr;
+ png_infop write_end_info_ptr;
++ int interlace_preserved = 1;
+ #else
+ png_structp write_ptr = NULL;
+ png_infop write_info_ptr = NULL;
+@@ -805,17 +875,11 @@
+ png_bytep row_buf;
+ png_uint_32 y;
+ png_uint_32 width, height;
+- int num_pass, pass;
++ int num_pass = 1, pass;
+ int bit_depth, color_type;
+-#ifdef PNG_SETJMP_SUPPORTED
+-#ifdef USE_FAR_KEYWORD
+- jmp_buf tmp_jmpbuf;
+-#endif
+-#endif
+-
+- char inbuf[256], outbuf[256];
+
+ row_buf = NULL;
++ error_parameters.file_name = inname;
+
+ if ((fpin = fopen(inname, "rb")) == NULL)
+ {
+@@ -839,20 +903,9 @@
+ read_ptr =
+ png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ #endif
+-#ifndef PNG_STDIO_SUPPORTED
+- png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,
+- pngtest_warning);
+-#endif
++ png_set_error_fn(read_ptr, &error_parameters, pngtest_error,
++ pngtest_warning);
+
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+- user_chunk_data[0] = 0;
+- user_chunk_data[1] = 0;
+- user_chunk_data[2] = 0;
+- user_chunk_data[3] = 0;
+- png_set_read_user_chunk_fn(read_ptr, user_chunk_data,
+- read_user_chunk_callback);
+-
+-#endif
+ #ifdef PNG_WRITE_SUPPORTED
+ #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+ write_ptr =
+@@ -862,10 +915,8 @@
+ write_ptr =
+ png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ #endif
+-#ifndef PNG_STDIO_SUPPORTED
+- png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,
+- pngtest_warning);
+-#endif
++ png_set_error_fn(write_ptr, &error_parameters, pngtest_error,
++ pngtest_warning);
+ #endif
+ pngtest_debug("Allocating read_info, write_info and end_info structures");
+ read_info_ptr = png_create_info_struct(read_ptr);
+@@ -875,13 +926,15 @@
+ write_end_info_ptr = png_create_info_struct(write_ptr);
+ #endif
+
++#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
++ init_callback_info(read_info_ptr);
++ png_set_read_user_chunk_fn(read_ptr, &user_chunk_data,
++ read_user_chunk_callback);
++#endif
++
+ #ifdef PNG_SETJMP_SUPPORTED
+ pngtest_debug("Setting jmpbuf for read struct");
+-#ifdef USE_FAR_KEYWORD
+- if (setjmp(tmp_jmpbuf))
+-#else
+ if (setjmp(png_jmpbuf(read_ptr)))
+-#endif
+ {
+ fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);
+ png_free(read_ptr, row_buf);
+@@ -895,18 +948,11 @@
+ FCLOSE(fpout);
+ return (1);
+ }
+-#ifdef USE_FAR_KEYWORD
+- png_memcpy(png_jmpbuf(read_ptr), tmp_jmpbuf, png_sizeof(jmp_buf));
+-#endif
+
+ #ifdef PNG_WRITE_SUPPORTED
+ pngtest_debug("Setting jmpbuf for write struct");
+-#ifdef USE_FAR_KEYWORD
+
+- if (setjmp(tmp_jmpbuf))
+-#else
+ if (setjmp(png_jmpbuf(write_ptr)))
+-#endif
+ {
+ fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);
+ png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
+@@ -918,12 +964,34 @@
+ FCLOSE(fpout);
+ return (1);
+ }
++#endif
++#endif
+
+-#ifdef USE_FAR_KEYWORD
+- png_memcpy(png_jmpbuf(write_ptr), tmp_jmpbuf, png_sizeof(jmp_buf));
++ if (strict != 0)
++ {
++ /* Treat png_benign_error() as errors on read */
++ png_set_benign_errors(read_ptr, 0);
++
++#ifdef PNG_WRITE_SUPPORTED
++ /* Treat them as errors on write */
++ png_set_benign_errors(write_ptr, 0);
+ #endif
++
++ /* if strict is not set, then app warnings and errors are treated as
++ * warnings in release builds, but not in unstable builds; this can be
++ * changed with '--relaxed'.
++ */
++ }
++
++ else if (relaxed != 0)
++ {
++ /* Allow application (pngtest) errors and warnings to pass */
++ png_set_benign_errors(read_ptr, 1);
++
++#ifdef PNG_WRITE_SUPPORTED
++ png_set_benign_errors(write_ptr, 1);
+ #endif
+-#endif
++ }
+
+ pngtest_debug("Initializing input and output streams");
+ #ifdef PNG_STDIO_SUPPORTED
+@@ -943,14 +1011,6 @@
+ # endif
+ #endif
+
+-#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+- /* Normally one would use Z_DEFAULT_STRATEGY for text compression.
+- * This is here just to make pngtest replicate the results from libpng
+- * versions prior to 1.5.4, and to test this new API.
+- */
+- png_set_text_compression_strategy(write_ptr, Z_FILTERED);
+-#endif
+-
+ if (status_dots_requested == 1)
+ {
+ #ifdef PNG_WRITE_SUPPORTED
+@@ -982,36 +1042,65 @@
+ png_set_write_user_transform_fn(write_ptr, count_zero_samples);
+ #endif
+
+-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+-# ifndef PNG_HANDLE_CHUNK_ALWAYS
+-# define PNG_HANDLE_CHUNK_ALWAYS 3
+-# endif
++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++ /* Preserve all the unknown chunks, if possible. If this is disabled then,
++ * even if the png_{get,set}_unknown_chunks stuff is enabled, we can't use
++ * libpng to *save* the unknown chunks on read (because we can't switch the
++ * save option on!)
++ *
++ * Notice that if SET_UNKNOWN_CHUNKS is *not* supported read will discard all
++ * unknown chunks and write will write them all.
++ */
++#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+ png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,
+ NULL, 0);
+ #endif
+ #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+-# ifndef PNG_HANDLE_CHUNK_IF_SAFE
+-# define PNG_HANDLE_CHUNK_IF_SAFE 2
+-# endif
+- png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,
++ png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS,
+ NULL, 0);
+ #endif
++#endif
+
+ pngtest_debug("Reading info struct");
+ png_read_info(read_ptr, read_info_ptr);
+
++#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
++ /* This is a bit of a hack; there is no obvious way in the callback function
++ * to determine that the chunks before the first IDAT have been read, so
++ * remove the info_ptr (which is only used to determine position relative to
++ * PLTE) here to indicate that we are after the IDAT.
++ */
++ user_chunk_data.info_ptr = NULL;
++#endif
++
+ pngtest_debug("Transferring info struct");
+ {
+ int interlace_type, compression_type, filter_type;
+
+ if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
+- &color_type, &interlace_type, &compression_type, &filter_type))
++ &color_type, &interlace_type, &compression_type, &filter_type) != 0)
+ {
+ png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
+-#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ color_type, interlace_type, compression_type, filter_type);
+-#else
+- color_type, PNG_INTERLACE_NONE, compression_type, filter_type);
++#ifndef PNG_READ_INTERLACING_SUPPORTED
++ /* num_pass will not be set below, set it here if the image is
++ * interlaced: what happens is that write interlacing is *not* turned
++ * on an the partial interlaced rows are written directly.
++ */
++ switch (interlace_type)
++ {
++ case PNG_INTERLACE_NONE:
++ num_pass = 1;
++ break;
++
++ case PNG_INTERLACE_ADAM7:
++ num_pass = 7;
++ break;
++
++ default:
++ png_error(read_ptr, "invalid interlace type");
++ /*NOT REACHED*/
++ }
+ #endif
+ }
+ }
+@@ -1022,7 +1111,7 @@
+ blue_y;
+
+ if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y,
+- &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y))
++ &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
+ {
+ png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,
+ red_y, green_x, green_y, blue_x, blue_y);
+@@ -1033,7 +1122,7 @@
+ {
+ png_fixed_point gamma;
+
+- if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))
++ if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma) != 0)
+ png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
+ }
+ #endif
+@@ -1045,7 +1134,7 @@
+ blue_y;
+
+ if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
+- &red_y, &green_x, &green_y, &blue_x, &blue_y))
++ &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
+ {
+ png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
+ red_y, green_x, green_y, blue_x, blue_y);
+@@ -1056,7 +1145,7 @@
+ {
+ double gamma;
+
+- if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
++ if (png_get_gAMA(read_ptr, read_info_ptr, &gamma) != 0)
+ png_set_gAMA(write_ptr, write_info_ptr, gamma);
+ }
+ #endif
+@@ -1070,7 +1159,7 @@
+ int compression_type;
+
+ if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,
+- &profile, &proflen))
++ &profile, &proflen) != 0)
+ {
+ png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,
+ profile, proflen);
+@@ -1081,7 +1170,7 @@
+ {
+ int intent;
+
+- if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
++ if (png_get_sRGB(read_ptr, read_info_ptr, &intent) != 0)
+ png_set_sRGB(write_ptr, write_info_ptr, intent);
+ }
+ #endif
+@@ -1089,14 +1178,14 @@
+ png_colorp palette;
+ int num_palette;
+
+- if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))
++ if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette) != 0)
+ png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
+ }
+ #ifdef PNG_bKGD_SUPPORTED
+ {
+ png_color_16p background;
+
+- if (png_get_bKGD(read_ptr, read_info_ptr, &background))
++ if (png_get_bKGD(read_ptr, read_info_ptr, &background) != 0)
+ {
+ png_set_bKGD(write_ptr, write_info_ptr, background);
+ }
+@@ -1106,7 +1195,7 @@
+ {
+ png_uint_16p hist;
+
+- if (png_get_hIST(read_ptr, read_info_ptr, &hist))
++ if (png_get_hIST(read_ptr, read_info_ptr, &hist) != 0)
+ png_set_hIST(write_ptr, write_info_ptr, hist);
+ }
+ #endif
+@@ -1116,7 +1205,7 @@
+ int unit_type;
+
+ if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,
+- &unit_type))
++ &unit_type) != 0)
+ {
+ png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
+ }
+@@ -1130,7 +1219,7 @@
+ int type, nparams;
+
+ if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
+- &nparams, &units, &params))
++ &nparams, &units, &params) != 0)
+ {
+ png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
+ nparams, units, params);
+@@ -1142,7 +1231,8 @@
+ png_uint_32 res_x, res_y;
+ int unit_type;
+
+- if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))
++ if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y,
++ &unit_type) != 0)
+ png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
+ }
+ #endif
+@@ -1150,18 +1240,19 @@
+ {
+ png_color_8p sig_bit;
+
+- if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
++ if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit) != 0)
+ png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
+ }
+ #endif
+ #ifdef PNG_sCAL_SUPPORTED
+-#ifdef PNG_FLOATING_POINT_SUPPORTED
++#if defined(PNG_FLOATING_POINT_SUPPORTED) && \
++ defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
+ {
+ int unit;
+ double scal_width, scal_height;
+
+ if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,
+- &scal_height))
++ &scal_height) != 0)
+ {
+ png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);
+ }
+@@ -1173,7 +1264,7 @@
+ png_charp scal_width, scal_height;
+
+ if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,
+- &scal_height))
++ &scal_height) != 0)
+ {
+ png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width,
+ scal_height);
+@@ -1190,6 +1281,21 @@
+ if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
+ {
+ pngtest_debug1("Handling %d iTXt/tEXt/zTXt chunks", num_text);
++
++ pngtest_check_text_support(read_ptr, text_ptr, num_text);
++
++ if (verbose != 0)
++ {
++ int i;
++
++ printf("\n");
++ for (i=0; i<num_text; i++)
++ {
++ printf(" Text compression[%d]=%d\n",
++ i, text_ptr[i].compression);
++ }
++ }
++
+ png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
+ }
+ }
+@@ -1198,21 +1304,21 @@
+ {
+ png_timep mod_time;
+
+- if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))
++ if (png_get_tIME(read_ptr, read_info_ptr, &mod_time) != 0)
+ {
+ png_set_tIME(write_ptr, write_info_ptr, mod_time);
+ #ifdef PNG_TIME_RFC1123_SUPPORTED
+- /* We have to use png_memcpy instead of "=" because the string
+- * pointed to by png_convert_to_rfc1123() gets free'ed before
+- * we use it.
+- */
+- png_memcpy(tIME_string,
+- png_convert_to_rfc1123(read_ptr, mod_time),
+- png_sizeof(tIME_string));
++ if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
++ tIME_string[(sizeof tIME_string) - 1] = '\0';
+
+- tIME_string[png_sizeof(tIME_string) - 1] = '\0';
++ else
++ {
++ strncpy(tIME_string, "*** invalid time ***", (sizeof tIME_string));
++ tIME_string[(sizeof tIME_string) - 1] = '\0';
++ }
++
+ tIME_chunk_present++;
+-#endif /* PNG_TIME_RFC1123_SUPPORTED */
++#endif /* TIME_RFC1123 */
+ }
+ }
+ #endif
+@@ -1223,7 +1329,7 @@
+ png_color_16p trans_color;
+
+ if (png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans,
+- &trans_color))
++ &trans_color) != 0)
+ {
+ int sample_max = (1 << bit_depth);
+ /* libpng doesn't reject a tRNS chunk with out-of-range samples */
+@@ -1244,18 +1350,22 @@
+ int num_unknowns = png_get_unknown_chunks(read_ptr, read_info_ptr,
+ &unknowns);
+
+- if (num_unknowns)
++ if (num_unknowns != 0)
+ {
+- int i;
+ png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
+ num_unknowns);
++#if PNG_LIBPNG_VER < 10600
+ /* Copy the locations from the read_info_ptr. The automatically
+- * generated locations in write_info_ptr are wrong because we
+- * haven't written anything yet.
++ * generated locations in write_end_info_ptr are wrong prior to 1.6.0
++ * because they are reset from the write pointer (removed in 1.6.0).
+ */
+- for (i = 0; i < num_unknowns; i++)
+- png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
+- unknowns[i].location);
++ {
++ int i;
++ for (i = 0; i < num_unknowns; i++)
++ png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
++ unknowns[i].location);
++ }
++#endif
+ }
+ }
+ #endif
+@@ -1263,47 +1373,16 @@
+ #ifdef PNG_WRITE_SUPPORTED
+ pngtest_debug("Writing info struct");
+
+-/* If we wanted, we could write info in two steps:
+- * png_write_info_before_PLTE(write_ptr, write_info_ptr);
+- */
++ /* Write the info in two steps so that if we write the 'unknown' chunks here
++ * they go to the correct place.
++ */
++ png_write_info_before_PLTE(write_ptr, write_info_ptr);
++
++ write_chunks(write_ptr, before_PLTE); /* before PLTE */
++
+ png_write_info(write_ptr, write_info_ptr);
+
+-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+- if (user_chunk_data[0] != 0)
+- {
+- png_byte png_sTER[5] = {115, 84, 69, 82, '\0'};
+-
+- unsigned char
+- ster_chunk_data[1];
+-
+- if (verbose)
+- fprintf(STDERR, "\n stereo mode = %lu\n",
+- (unsigned long)(user_chunk_data[0] - 1));
+-
+- ster_chunk_data[0]=(unsigned char)(user_chunk_data[0] - 1);
+- png_write_chunk(write_ptr, png_sTER, ster_chunk_data, 1);
+- }
+-
+- if (user_chunk_data[1] != 0 || user_chunk_data[2] != 0)
+- {
+- png_byte png_vpAg[5] = {118, 112, 65, 103, '\0'};
+-
+- unsigned char
+- vpag_chunk_data[9];
+-
+- if (verbose)
+- fprintf(STDERR, " vpAg = %lu x %lu, units = %lu\n",
+- (unsigned long)user_chunk_data[1],
+- (unsigned long)user_chunk_data[2],
+- (unsigned long)user_chunk_data[3]);
+-
+- png_save_uint_32(vpag_chunk_data, user_chunk_data[1]);
+- png_save_uint_32(vpag_chunk_data + 4, user_chunk_data[2]);
+- vpag_chunk_data[8] = (unsigned char)(user_chunk_data[3] & 0xff);
+- png_write_chunk(write_ptr, png_vpAg, vpag_chunk_data, 9);
+- }
+-
+-#endif
++ write_chunks(write_ptr, before_IDAT); /* after PLTE */
+ #endif
+
+ #ifdef SINGLE_ROWBUF_ALLOC
+@@ -1315,14 +1394,10 @@
+ #endif /* SINGLE_ROWBUF_ALLOC */
+ pngtest_debug("Writing row data");
+
+-#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+- defined(PNG_WRITE_INTERLACING_SUPPORTED)
++#ifdef PNG_READ_INTERLACING_SUPPORTED
+ num_pass = png_set_interlace_handling(read_ptr);
+-# ifdef PNG_WRITE_SUPPORTED
+- png_set_interlace_handling(write_ptr);
+-# endif
+-#else
+- num_pass = 1;
++ if (png_set_interlace_handling(write_ptr) != num_pass)
++ png_error(write_ptr, "png_set_interlace_handling: inconsistent num_pass");
+ #endif
+
+ #ifdef PNGTEST_TIMING
+@@ -1337,11 +1412,12 @@
+ {
+ #ifndef SINGLE_ROWBUF_ALLOC
+ pngtest_debug2("Allocating row buffer (pass %d, y = %u)...", pass, y);
++
+ row_buf = (png_bytep)png_malloc(read_ptr,
+ png_get_rowbytes(read_ptr, read_info_ptr));
+
+- pngtest_debug2("\t0x%08lx (%u bytes)", (unsigned long)row_buf,
+- png_get_rowbytes(read_ptr, read_info_ptr));
++ pngtest_debug2("\t0x%08lx (%lu bytes)", (unsigned long)row_buf,
++ (unsigned long)png_get_rowbytes(read_ptr, read_info_ptr));
+
+ #endif /* !SINGLE_ROWBUF_ALLOC */
+ png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1);
+@@ -1358,7 +1434,7 @@
+ t_encode += (t_stop - t_start);
+ t_start = t_stop;
+ #endif
+-#endif /* PNG_WRITE_SUPPORTED */
++#endif /* WRITE */
+
+ #ifndef SINGLE_ROWBUF_ALLOC
+ pngtest_debug2("Freeing row buffer (pass %d, y = %u)", pass, y);
+@@ -1368,11 +1444,13 @@
+ }
+ }
+
+-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+- png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);
+-#endif
+-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+- png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);
++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
++# ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
++ png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);
++# endif
++# ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
++ png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);
++# endif
+ #endif
+
+ pngtest_debug("Reading and writing end_info data");
+@@ -1386,6 +1464,21 @@
+ if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)
+ {
+ pngtest_debug1("Handling %d iTXt/tEXt/zTXt chunks", num_text);
++
++ pngtest_check_text_support(read_ptr, text_ptr, num_text);
++
++ if (verbose != 0)
++ {
++ int i;
++
++ printf("\n");
++ for (i=0; i<num_text; i++)
++ {
++ printf(" Text compression[%d]=%d\n",
++ i, text_ptr[i].compression);
++ }
++ }
++
+ png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);
+ }
+ }
+@@ -1394,20 +1487,21 @@
+ {
+ png_timep mod_time;
+
+- if (png_get_tIME(read_ptr, end_info_ptr, &mod_time))
++ if (png_get_tIME(read_ptr, end_info_ptr, &mod_time) != 0)
+ {
+ png_set_tIME(write_ptr, write_end_info_ptr, mod_time);
+ #ifdef PNG_TIME_RFC1123_SUPPORTED
+- /* We have to use png_memcpy instead of "=" because the string
+- pointed to by png_convert_to_rfc1123() gets free'ed before
+- we use it */
+- png_memcpy(tIME_string,
+- png_convert_to_rfc1123(read_ptr, mod_time),
+- png_sizeof(tIME_string));
++ if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
++ tIME_string[(sizeof tIME_string) - 1] = '\0';
+
+- tIME_string[png_sizeof(tIME_string) - 1] = '\0';
++ else
++ {
++ strncpy(tIME_string, "*** invalid time ***", sizeof tIME_string);
++ tIME_string[(sizeof tIME_string)-1] = '\0';
++ }
++
+ tIME_chunk_present++;
+-#endif /* PNG_TIME_RFC1123_SUPPORTED */
++#endif /* TIME_RFC1123 */
+ }
+ }
+ #endif
+@@ -1417,27 +1511,48 @@
+ int num_unknowns = png_get_unknown_chunks(read_ptr, end_info_ptr,
+ &unknowns);
+
+- if (num_unknowns)
++ if (num_unknowns != 0)
+ {
+- int i;
+ png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
+ num_unknowns);
++#if PNG_LIBPNG_VER < 10600
+ /* Copy the locations from the read_info_ptr. The automatically
+- * generated locations in write_end_info_ptr are wrong because we
+- * haven't written the end_info yet.
++ * generated locations in write_end_info_ptr are wrong prior to 1.6.0
++ * because they are reset from the write pointer (removed in 1.6.0).
+ */
+- for (i = 0; i < num_unknowns; i++)
+- png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
+- unknowns[i].location);
++ {
++ int i;
++ for (i = 0; i < num_unknowns; i++)
++ png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
++ unknowns[i].location);
++ }
++#endif
+ }
+ }
+ #endif
++
+ #ifdef PNG_WRITE_SUPPORTED
++#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
++ /* Normally one would use Z_DEFAULT_STRATEGY for text compression.
++ * This is here just to make pngtest replicate the results from libpng
++ * versions prior to 1.5.4, and to test this new API.
++ */
++ png_set_text_compression_strategy(write_ptr, Z_FILTERED);
++#endif
++
++ /* When the unknown vpAg/sTER chunks are written by pngtest the only way to
++ * do it is to write them *before* calling png_write_end. When unknown
++ * chunks are written by libpng, however, they are written just before IEND.
++ * There seems to be no way round this, however vpAg/sTER are not expected
++ * after IDAT.
++ */
++ write_chunks(write_ptr, after_IDAT);
++
+ png_write_end(write_ptr, write_end_info_ptr);
+ #endif
+
+ #ifdef PNG_EASY_ACCESS_SUPPORTED
+- if (verbose)
++ if (verbose != 0)
+ {
+ png_uint_32 iwidth, iheight;
+ iwidth = png_get_image_width(write_ptr, write_info_ptr);
+@@ -1466,6 +1581,40 @@
+ FCLOSE(fpin);
+ FCLOSE(fpout);
+
++ /* Summarize any warnings or errors and in 'strict' mode fail the test.
++ * Unsupported chunks can result in warnings, in that case ignore the strict
++ * setting, otherwise fail the test on warnings as well as errors.
++ */
++ if (error_count > 0)
++ {
++ /* We don't really expect to get here because of the setjmp handling
++ * above, but this is safe.
++ */
++ fprintf(STDERR, "\n %s: %d libpng errors found (%d warnings)",
++ inname, error_count, warning_count);
++
++ if (strict != 0)
++ return (1);
++ }
++
++# ifdef PNG_WRITE_SUPPORTED
++ /* If there we no write support nothing was written! */
++ else if (unsupported_chunks > 0)
++ {
++ fprintf(STDERR, "\n %s: unsupported chunks (%d)%s",
++ inname, unsupported_chunks, strict ? ": IGNORED --strict!" : "");
++ }
++# endif
++
++ else if (warning_count > 0)
++ {
++ fprintf(STDERR, "\n %s: %d libpng warnings found",
++ inname, warning_count);
++
++ if (strict != 0)
++ return (1);
++ }
++
+ pngtest_debug("Opening files for comparison");
+ if ((fpin = fopen(inname, "rb")) == NULL)
+ {
+@@ -1480,61 +1629,84 @@
+ return (1);
+ }
+
+- for (;;)
++#ifdef PNG_WRITE_SUPPORTED /* else nothing was written */
++ if (interlace_preserved != 0) /* else the files will be changed */
+ {
+- png_size_t num_in, num_out;
++ for (;;)
++ {
++ static int wrote_question = 0;
++ png_size_t num_in, num_out;
++ char inbuf[256], outbuf[256];
+
+- num_in = fread(inbuf, 1, 1, fpin);
+- num_out = fread(outbuf, 1, 1, fpout);
++ num_in = fread(inbuf, 1, sizeof inbuf, fpin);
++ num_out = fread(outbuf, 1, sizeof outbuf, fpout);
+
+- if (num_in != num_out)
+- {
+- fprintf(STDERR, "\nFiles %s and %s are of a different size\n",
+- inname, outname);
++ if (num_in != num_out)
++ {
++ fprintf(STDERR, "\nFiles %s and %s are of a different size\n",
++ inname, outname);
+
+- if (wrote_question == 0)
+- {
+- fprintf(STDERR,
++ if (wrote_question == 0 && unsupported_chunks == 0)
++ {
++ fprintf(STDERR,
+ " Was %s written with the same maximum IDAT chunk size (%d bytes),",
+- inname, PNG_ZBUF_SIZE);
+- fprintf(STDERR,
+- "\n filtering heuristic (libpng default), compression");
+- fprintf(STDERR,
+- " level (zlib default),\n and zlib version (%s)?\n\n",
+- ZLIB_VERSION);
+- wrote_question = 1;
++ inname, PNG_ZBUF_SIZE);
++ fprintf(STDERR,
++ "\n filtering heuristic (libpng default), compression");
++ fprintf(STDERR,
++ " level (zlib default),\n and zlib version (%s)?\n\n",
++ ZLIB_VERSION);
++ wrote_question = 1;
++ }
++
++ FCLOSE(fpin);
++ FCLOSE(fpout);
++
++ if (strict != 0 && unsupported_chunks == 0)
++ return (1);
++
++ else
++ return (0);
+ }
+
+- FCLOSE(fpin);
+- FCLOSE(fpout);
+- return (0);
+- }
++ if (num_in == 0)
++ break;
+
+- if (!num_in)
+- break;
++ if (memcmp(inbuf, outbuf, num_in))
++ {
++ fprintf(STDERR, "\nFiles %s and %s are different\n", inname,
++ outname);
+
+- if (png_memcmp(inbuf, outbuf, num_in))
+- {
+- fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);
++ if (wrote_question == 0 && unsupported_chunks == 0)
++ {
++ fprintf(STDERR,
++ " Was %s written with the same maximum IDAT chunk size (%d bytes),",
++ inname, PNG_ZBUF_SIZE);
++ fprintf(STDERR,
++ "\n filtering heuristic (libpng default), compression");
++ fprintf(STDERR,
++ " level (zlib default),\n and zlib version (%s)?\n\n",
++ ZLIB_VERSION);
++ wrote_question = 1;
++ }
+
+- if (wrote_question == 0)
+- {
+- fprintf(STDERR,
+- " Was %s written with the same maximum IDAT chunk size (%d bytes),",
+- inname, PNG_ZBUF_SIZE);
+- fprintf(STDERR,
+- "\n filtering heuristic (libpng default), compression");
+- fprintf(STDERR,
+- " level (zlib default),\n and zlib version (%s)?\n\n",
+- ZLIB_VERSION);
+- wrote_question = 1;
++ FCLOSE(fpin);
++ FCLOSE(fpout);
++
++ /* NOTE: the unsupported_chunks escape is permitted here because
++ * unsupported text chunk compression will result in the compression
++ * mode being changed (to NONE) yet, in the test case, the result
++ * can be exactly the same size!
++ */
++ if (strict != 0 && unsupported_chunks == 0)
++ return (1);
++
++ else
++ return (0);
+ }
+-
+- FCLOSE(fpin);
+- FCLOSE(fpout);
+- return (0);
+ }
+ }
++#endif /* WRITE */
+
+ FCLOSE(fpin);
+ FCLOSE(fpout);
+@@ -1614,6 +1786,24 @@
+ inname = argv[2];
+ }
+
++ else if (strcmp(argv[1], "--strict") == 0)
++ {
++ status_dots_requested = 0;
++ verbose = 1;
++ inname = argv[2];
++ strict++;
++ relaxed = 0;
++ }
++
++ else if (strcmp(argv[1], "--relaxed") == 0)
++ {
++ status_dots_requested = 0;
++ verbose = 1;
++ inname = argv[2];
++ strict = 0;
++ relaxed++;
++ }
++
+ else
+ {
+ inname = argv[1];
+@@ -1621,10 +1811,11 @@
+ }
+ }
+
+- if (!multiple && argc == 3 + verbose)
++ if (multiple == 0 && argc == 3 + verbose)
+ outname = argv[2 + verbose];
+
+- if ((!multiple && argc > 3 + verbose) || (multiple && argc < 2))
++ if ((multiple == 0 && argc > 3 + verbose) ||
++ (multiple != 0 && argc < 2))
+ {
+ fprintf(STDERR,
+ "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
+@@ -1636,7 +1827,7 @@
+ exit(1);
+ }
+
+- if (multiple)
++ if (multiple != 0)
+ {
+ int i;
+ #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
+@@ -1646,6 +1837,9 @@
+ {
+ int kerror;
+ fprintf(STDERR, "\n Testing %s:", argv[i]);
++#if PNG_DEBUG > 0
++ fprintf(STDERR, "\n");
++#endif
+ kerror = test_one_file(argv[i], outname);
+ if (kerror == 0)
+ {
+@@ -1660,7 +1854,7 @@
+ #endif
+ #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+ for (k = 0; k<256; k++)
+- if (filters_used[k])
++ if (filters_used[k] != 0)
+ fprintf(STDERR, " Filter %d was used %lu times\n",
+ k, (unsigned long)filters_used[k]);
+ #endif
+@@ -1669,7 +1863,7 @@
+ fprintf(STDERR, " tIME = %s\n", tIME_string);
+
+ tIME_chunk_present = 0;
+-#endif /* PNG_TIME_RFC1123_SUPPORTED */
++#endif /* TIME_RFC1123 */
+ }
+
+ else
+@@ -1691,9 +1885,9 @@
+
+ while (pinfo != NULL)
+ {
+- fprintf(STDERR, " %lu bytes at %x\n",
++ fprintf(STDERR, " %lu bytes at %p\n",
+ (unsigned long)pinfo->size,
+- (unsigned int)pinfo->pointer);
++ pinfo->pointer);
+ pinfo = pinfo->next;
+ }
+ }
+@@ -1727,7 +1921,12 @@
+ status_dots_requested = 0;
+
+ if (i == 0 || verbose == 1 || ierror != 0)
++ {
+ fprintf(STDERR, "\n Testing %s:", inname);
++#if PNG_DEBUG > 0
++ fprintf(STDERR, "\n");
++#endif
++ }
+
+ kerror = test_one_file(inname, outname);
+
+@@ -1746,21 +1945,26 @@
+ #endif
+ #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+ for (k = 0; k<256; k++)
+- if (filters_used[k])
++ if (filters_used[k] != 0)
+ fprintf(STDERR, " Filter %d was used %lu times\n",
+ k, (unsigned long)filters_used[k]);
+ #endif
+ #ifdef PNG_TIME_RFC1123_SUPPORTED
+ if (tIME_chunk_present != 0)
+ fprintf(STDERR, " tIME = %s\n", tIME_string);
+-#endif /* PNG_TIME_RFC1123_SUPPORTED */
++#endif /* TIME_RFC1123 */
+ }
+ }
+
+ else
+ {
+ if (verbose == 0 && i != 2)
++ {
+ fprintf(STDERR, "\n Testing %s:", inname);
++#if PNG_DEBUG > 0
++ fprintf(STDERR, "\n");
++#endif
++ }
+
+ fprintf(STDERR, " FAIL\n");
+ ierror += kerror;
+@@ -1779,8 +1983,8 @@
+
+ while (pinfo != NULL)
+ {
+- fprintf(STDERR, " %lu bytes at %x\n",
+- (unsigned long)pinfo->size, (unsigned int)pinfo->pointer);
++ fprintf(STDERR, " %lu bytes at %p\n",
++ (unsigned long)pinfo->size, pinfo->pointer);
+ pinfo = pinfo->next;
+ }
+ }
+@@ -1820,6 +2024,16 @@
+
+ return (int)(ierror != 0);
+ }
++#else
++int
++main(void)
++{
++ fprintf(STDERR,
++ " test ignored because libpng was not built with read support\n");
++ /* And skip this test */
++ return PNG_LIBPNG_VER < 10600 ? 0 : 77;
++}
++#endif
+
+ /* Generate a compiler error if there is an old png.h in the search path. */
+-typedef png_libpng_version_1_5_4 Your_png_h_is_not_version_1_5_4;
++typedef png_libpng_version_1_6_16 Your_png_h_is_not_version_1_6_16;
+--- ./jdk/src/share/native/sun/awt/libpng/pngtrans.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngtrans.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -46,7 +46,7 @@
+ #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+ /* Turn on BGR-to-RGB mapping */
+ void PNGAPI
+-png_set_bgr(png_structp png_ptr)
++png_set_bgr(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_bgr");
+
+@@ -60,7 +60,7 @@
+ #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+ /* Turn on 16 bit byte swapping */
+ void PNGAPI
+-png_set_swap(png_structp png_ptr)
++png_set_swap(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_swap");
+
+@@ -75,7 +75,7 @@
+ #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+ /* Turn on pixel packing */
+ void PNGAPI
+-png_set_packing(png_structp png_ptr)
++png_set_packing(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_packing");
+
+@@ -85,7 +85,9 @@
+ if (png_ptr->bit_depth < 8)
+ {
+ png_ptr->transformations |= PNG_PACK;
+- png_ptr->usr_bit_depth = 8;
++# ifdef PNG_WRITE_SUPPORTED
++ png_ptr->usr_bit_depth = 8;
++# endif
+ }
+ }
+ #endif
+@@ -93,7 +95,7 @@
+ #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+ /* Turn on packed pixel swapping */
+ void PNGAPI
+-png_set_packswap(png_structp png_ptr)
++png_set_packswap(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_packswap");
+
+@@ -107,7 +109,7 @@
+
+ #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+ void PNGAPI
+-png_set_shift(png_structp png_ptr, png_const_color_8p true_bits)
++png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits)
+ {
+ png_debug(1, "in png_set_shift");
+
+@@ -122,11 +124,11 @@
+ #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+ defined(PNG_WRITE_INTERLACING_SUPPORTED)
+ int PNGAPI
+-png_set_interlace_handling(png_structp png_ptr)
++png_set_interlace_handling(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_interlace handling");
+
+- if (png_ptr && png_ptr->interlaced)
++ if (png_ptr != 0 && png_ptr->interlaced != 0)
+ {
+ png_ptr->transformations |= PNG_INTERLACE;
+ return (7);
+@@ -143,44 +145,91 @@
+ * that don't like bytes as parameters.
+ */
+ void PNGAPI
+-png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
++png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
+ {
+ png_debug(1, "in png_set_filler");
+
+ if (png_ptr == NULL)
+ return;
+
++ /* In libpng 1.6 it is possible to determine whether this is a read or write
++ * operation and therefore to do more checking here for a valid call.
++ */
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
++ {
++# ifdef PNG_READ_FILLER_SUPPORTED
++ /* On read png_set_filler is always valid, regardless of the base PNG
++ * format, because other transformations can give a format where the
++ * filler code can execute (basically an 8 or 16-bit component RGB or G
++ * format.)
++ *
++ * NOTE: usr_channels is not used by the read code! (This has led to
++ * confusion in the past.) The filler is only used in the read code.
++ */
++ png_ptr->filler = (png_uint_16)filler;
++# else
++ png_app_error(png_ptr, "png_set_filler not supported on read");
++ PNG_UNUSED(filler) /* not used in the write case */
++ return;
++# endif
++ }
++
++ else /* write */
++ {
++# ifdef PNG_WRITE_FILLER_SUPPORTED
++ /* On write the usr_channels parameter must be set correctly at the
++ * start to record the number of channels in the app-supplied data.
++ */
++ switch (png_ptr->color_type)
++ {
++ case PNG_COLOR_TYPE_RGB:
++ png_ptr->usr_channels = 4;
++ break;
++
++ case PNG_COLOR_TYPE_GRAY:
++ if (png_ptr->bit_depth >= 8)
++ {
++ png_ptr->usr_channels = 2;
++ break;
++ }
++
++ else
++ {
++ /* There simply isn't any code in libpng to strip out bits
++ * from bytes when the components are less than a byte in
++ * size!
++ */
++ png_app_error(png_ptr,
++ "png_set_filler is invalid for low bit depth gray output");
++ return;
++ }
++
++ default:
++ png_app_error(png_ptr,
++ "png_set_filler: inappropriate color type");
++ return;
++ }
++# else
++ png_app_error(png_ptr, "png_set_filler not supported on write");
++ return;
++# endif
++ }
++
++ /* Here on success - libpng supports the operation, set the transformation
++ * and the flag to say where the filler channel is.
++ */
+ png_ptr->transformations |= PNG_FILLER;
+- png_ptr->filler = (png_uint_16)filler;
+
+ if (filler_loc == PNG_FILLER_AFTER)
+ png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
+
+ else
+ png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
+-
+- /* This should probably go in the "do_read_filler" routine.
+- * I attempted to do that in libpng-1.0.1a but that caused problems
+- * so I restored it in libpng-1.0.2a
+- */
+-
+- if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+- {
+- png_ptr->usr_channels = 4;
+- }
+-
+- /* Also I added this in libpng-1.0.2a (what happens when we expand
+- * a less-than-8-bit grayscale to GA?) */
+-
+- if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
+- {
+- png_ptr->usr_channels = 2;
+- }
+ }
+
+ /* Added to libpng-1.2.7 */
+ void PNGAPI
+-png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
++png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
+ {
+ png_debug(1, "in png_set_add_alpha");
+
+@@ -188,7 +237,9 @@
+ return;
+
+ png_set_filler(png_ptr, filler, filler_loc);
+- png_ptr->transformations |= PNG_ADD_ALPHA;
++ /* The above may fail to do anything. */
++ if ((png_ptr->transformations & PNG_FILLER) != 0)
++ png_ptr->transformations |= PNG_ADD_ALPHA;
+ }
+
+ #endif
+@@ -196,7 +247,7 @@
+ #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+ void PNGAPI
+-png_set_swap_alpha(png_structp png_ptr)
++png_set_swap_alpha(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_swap_alpha");
+
+@@ -210,7 +261,7 @@
+ #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+ void PNGAPI
+-png_set_invert_alpha(png_structp png_ptr)
++png_set_invert_alpha(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_invert_alpha");
+
+@@ -223,7 +274,7 @@
+
+ #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+ void PNGAPI
+-png_set_invert_mono(png_structp png_ptr)
++png_set_invert_mono(png_structrp png_ptr)
+ {
+ png_debug(1, "in png_set_invert_mono");
+
+@@ -304,9 +355,16 @@
+
+ for (i = 0; i < istop; i++, rp += 2)
+ {
++#ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
++ /* Feature added to libpng-1.6.11 for testing purposes, not
++ * enabled by default.
++ */
++ *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
++#else
+ png_byte t = *rp;
+ *rp = *(rp + 1);
+ *(rp + 1) = t;
++#endif
+ }
+ }
+ }
+@@ -448,7 +506,7 @@
+ *rp = table[*rp];
+ }
+ }
+-#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
++#endif /* PACKSWAP || WRITE_PACKSWAP */
+
+ #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
+ defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+@@ -480,7 +538,7 @@
+ {
+ if (row_info->bit_depth == 8)
+ {
+- if (at_start) /* Skip initial filler */
++ if (at_start != 0) /* Skip initial filler */
+ ++sp;
+ else /* Skip initial channel and, for sp, the filler */
+ sp += 2, ++dp;
+@@ -494,7 +552,7 @@
+
+ else if (row_info->bit_depth == 16)
+ {
+- if (at_start) /* Skip initial filler */
++ if (at_start != 0) /* Skip initial filler */
+ sp += 2;
+ else /* Skip initial channel and, for sp, the filler */
+ sp += 4, dp += 2;
+@@ -520,7 +578,7 @@
+ {
+ if (row_info->bit_depth == 8)
+ {
+- if (at_start) /* Skip initial filler */
++ if (at_start != 0) /* Skip initial filler */
+ ++sp;
+ else /* Skip initial channels and, for sp, the filler */
+ sp += 4, dp += 3;
+@@ -534,7 +592,7 @@
+
+ else if (row_info->bit_depth == 16)
+ {
+- if (at_start) /* Skip initial filler */
++ if (at_start != 0) /* Skip initial filler */
+ sp += 2;
+ else /* Skip initial channels and, for sp, the filler */
+ sp += 8, dp += 6;
+@@ -575,7 +633,7 @@
+ {
+ png_debug(1, "in png_do_bgr");
+
+- if ((row_info->color_type & PNG_COLOR_MASK_COLOR))
++ if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+ png_uint_32 row_width = row_info->width;
+ if (row_info->bit_depth == 8)
+@@ -645,19 +703,133 @@
+ #endif
+ }
+ }
+-#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
++#endif /* READ_BGR || WRITE_BGR */
++
++#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
++ defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
++/* Added at libpng-1.5.10 */
++void /* PRIVATE */
++png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
++{
++ if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
++ png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
++ {
++ /* Calculations moved outside switch in an attempt to stop different
++ * compiler warnings. 'padding' is in *bits* within the last byte, it is
++ * an 'int' because pixel_depth becomes an 'int' in the expression below,
++ * and this calculation is used because it avoids warnings that other
++ * forms produced on either GCC or MSVC.
++ */
++ int padding = (-row_info->pixel_depth * row_info->width) & 7;
++ png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
++
++ switch (row_info->bit_depth)
++ {
++ case 1:
++ {
++ /* in this case, all bytes must be 0 so we don't need
++ * to unpack the pixels except for the rightmost one.
++ */
++ for (; rp > png_ptr->row_buf; rp--)
++ {
++ if (*rp >> padding != 0)
++ png_ptr->num_palette_max = 1;
++ padding = 0;
++ }
++
++ break;
++ }
++
++ case 2:
++ {
++ for (; rp > png_ptr->row_buf; rp--)
++ {
++ int i = ((*rp >> padding) & 0x03);
++
++ if (i > png_ptr->num_palette_max)
++ png_ptr->num_palette_max = i;
++
++ i = (((*rp >> padding) >> 2) & 0x03);
++
++ if (i > png_ptr->num_palette_max)
++ png_ptr->num_palette_max = i;
++
++ i = (((*rp >> padding) >> 4) & 0x03);
++
++ if (i > png_ptr->num_palette_max)
++ png_ptr->num_palette_max = i;
++
++ i = (((*rp >> padding) >> 6) & 0x03);
++
++ if (i > png_ptr->num_palette_max)
++ png_ptr->num_palette_max = i;
++
++ padding = 0;
++ }
++
++ break;
++ }
++
++ case 4:
++ {
++ for (; rp > png_ptr->row_buf; rp--)
++ {
++ int i = ((*rp >> padding) & 0x0f);
++
++ if (i > png_ptr->num_palette_max)
++ png_ptr->num_palette_max = i;
++
++ i = (((*rp >> padding) >> 4) & 0x0f);
++
++ if (i > png_ptr->num_palette_max)
++ png_ptr->num_palette_max = i;
++
++ padding = 0;
++ }
++
++ break;
++ }
++
++ case 8:
++ {
++ for (; rp > png_ptr->row_buf; rp--)
++ {
++ if (*rp > png_ptr->num_palette_max)
++ png_ptr->num_palette_max = (int) *rp;
++ }
++
++ break;
++ }
++
++ default:
++ break;
++ }
++ }
++}
++#endif /* CHECK_FOR_INVALID_INDEX */
+
+ #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+ #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+ void PNGAPI
+-png_set_user_transform_info(png_structp png_ptr, png_voidp
++png_set_user_transform_info(png_structrp png_ptr, png_voidp
+ user_transform_ptr, int user_transform_depth, int user_transform_channels)
+ {
+ png_debug(1, "in png_set_user_transform_info");
+
+ if (png_ptr == NULL)
+ return;
++
++#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
++ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
++ (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
++ {
++ png_app_error(png_ptr,
++ "info change after png_start_read_image or png_read_update_info");
++ return;
++ }
++#endif
++
+ png_ptr->user_transform_ptr = user_transform_ptr;
+ png_ptr->user_transform_depth = (png_byte)user_transform_depth;
+ png_ptr->user_transform_channels = (png_byte)user_transform_channels;
+@@ -671,20 +843,20 @@
+ */
+ #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+ png_voidp PNGAPI
+-png_get_user_transform_ptr(png_const_structp png_ptr)
++png_get_user_transform_ptr(png_const_structrp png_ptr)
+ {
+ if (png_ptr == NULL)
+ return (NULL);
+
+- return ((png_voidp)png_ptr->user_transform_ptr);
++ return png_ptr->user_transform_ptr;
+ }
+ #endif
+
+ #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
+ png_uint_32 PNGAPI
+-png_get_current_row_number(png_const_structp png_ptr)
++png_get_current_row_number(png_const_structrp png_ptr)
+ {
+- /* See the comments in png.h - this is the sub-image row when reading and
++ /* See the comments in png.h - this is the sub-image row when reading an
+ * interlaced image.
+ */
+ if (png_ptr != NULL)
+@@ -694,13 +866,12 @@
+ }
+
+ png_byte PNGAPI
+-png_get_current_pass_number(png_const_structp png_ptr)
++png_get_current_pass_number(png_const_structrp png_ptr)
+ {
+ if (png_ptr != NULL)
+ return png_ptr->pass;
+ return 8; /* invalid */
+ }
+-#endif /* PNG_USER_TRANSFORM_INFO_SUPPORTED */
+-#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED ||
+- PNG_WRITE_USER_TRANSFORM_SUPPORTED */
+-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
++#endif /* USER_TRANSFORM_INFO */
++#endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
++#endif /* READ || WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pngwio.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngwio.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.0 [January 6, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -58,11 +58,12 @@
+ */
+
+ void /* PRIVATE */
+-png_write_data(png_structp png_ptr, png_const_bytep data, png_size_t length)
++png_write_data(png_structrp png_ptr, png_const_bytep data, png_size_t length)
+ {
+ /* NOTE: write_data_fn must not change the buffer! */
+ if (png_ptr->write_data_fn != NULL )
+- (*(png_ptr->write_data_fn))(png_ptr, (png_bytep)data, length);
++ (*(png_ptr->write_data_fn))(png_ptr, png_constcast(png_bytep,data),
++ length);
+
+ else
+ png_error(png_ptr, "Call to NULL write function");
+@@ -74,7 +75,6 @@
+ * write_data function and use it at run time with png_set_write_fn(), rather
+ * than changing the library.
+ */
+-#ifndef USE_FAR_KEYWORD
+ void PNGCBAPI
+ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+ {
+@@ -88,64 +88,6 @@
+ if (check != length)
+ png_error(png_ptr, "Write Error");
+ }
+-#else
+-/* This is the model-independent version. Since the standard I/O library
+- * can't handle far buffers in the medium and small models, we have to copy
+- * the data.
+- */
+-
+-#define NEAR_BUF_SIZE 1024
+-#define MIN(a,b) (a <= b ? a : b)
+-
+-void PNGCBAPI
+-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+-{
+- png_uint_32 check;
+- png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */
+- png_FILE_p io_ptr;
+-
+- if (png_ptr == NULL)
+- return;
+-
+- /* Check if data really is near. If so, use usual code. */
+- near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+-
+- if ((png_bytep)near_data == data)
+- {
+- check = fwrite(near_data, 1, length, io_ptr);
+- }
+-
+- else
+- {
+- png_byte buf[NEAR_BUF_SIZE];
+- png_size_t written, remaining, err;
+- check = 0;
+- remaining = length;
+-
+- do
+- {
+- written = MIN(NEAR_BUF_SIZE, remaining);
+- png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
+- err = fwrite(buf, 1, written, io_ptr);
+-
+- if (err != written)
+- break;
+-
+- else
+- check += err;
+-
+- data += written;
+- remaining -= written;
+- }
+- while (remaining != 0);
+- }
+-
+- if (check != length)
+- png_error(png_ptr, "Write Error");
+-}
+-
+-#endif
+ #endif
+
+ /* This function is called to output any data pending writing (normally
+@@ -154,7 +96,7 @@
+ */
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+ void /* PRIVATE */
+-png_flush(png_structp png_ptr)
++png_flush(png_structrp png_ptr)
+ {
+ if (png_ptr->output_flush_fn != NULL)
+ (*(png_ptr->output_flush_fn))(png_ptr);
+@@ -169,7 +111,7 @@
+ if (png_ptr == NULL)
+ return;
+
+- io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
++ io_ptr = png_voidcast(png_FILE_p, (png_ptr->io_ptr));
+ fflush(io_ptr);
+ }
+ # endif
+@@ -205,7 +147,7 @@
+ * *FILE structure.
+ */
+ void PNGAPI
+-png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
++png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr,
+ png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
+ {
+ if (png_ptr == NULL)
+@@ -235,8 +177,11 @@
+ # else
+ png_ptr->output_flush_fn = output_flush_fn;
+ # endif
+-#endif /* PNG_WRITE_FLUSH_SUPPORTED */
++#else
++ PNG_UNUSED(output_flush_fn)
++#endif /* WRITE_FLUSH */
+
++#ifdef PNG_READ_SUPPORTED
+ /* It is an error to read while writing a png file */
+ if (png_ptr->read_data_fn != NULL)
+ {
+@@ -246,37 +191,6 @@
+ "Can't set both read_data_fn and write_data_fn in the"
+ " same structure");
+ }
++#endif
+ }
+-
+-#ifdef USE_FAR_KEYWORD
+-# ifdef _MSC_VER
+-void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+-{
+- void *near_ptr;
+- void FAR *far_ptr;
+- FP_OFF(near_ptr) = FP_OFF(ptr);
+- far_ptr = (void FAR *)near_ptr;
+-
+- if (check != 0)
+- if (FP_SEG(ptr) != FP_SEG(far_ptr))
+- png_error(png_ptr, "segment lost in conversion");
+-
+- return(near_ptr);
+-}
+-# else
+-void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+-{
+- void *near_ptr;
+- void FAR *far_ptr;
+- near_ptr = (void FAR *)ptr;
+- far_ptr = (void FAR *)near_ptr;
+-
+- if (check != 0)
+- if (far_ptr != ptr)
+- png_error(png_ptr, "segment lost in conversion");
+-
+- return(near_ptr);
+-}
+-# endif
+-#endif
+-#endif /* PNG_WRITE_SUPPORTED */
++#endif /* WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pngwrite.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngwrite.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -40,9 +40,65 @@
+ */
+
+ #include "pngpriv.h"
++#if defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
++# include <errno.h>
++#endif
+
+ #ifdef PNG_WRITE_SUPPORTED
+
++#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
++/* Write out all the unknown chunks for the current given location */
++static void
++write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,
++ unsigned int where)
++{
++ if (info_ptr->unknown_chunks_num != 0)
++ {
++ png_const_unknown_chunkp up;
++
++ png_debug(5, "writing extra chunks");
++
++ for (up = info_ptr->unknown_chunks;
++ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
++ ++up)
++ if ((up->location & where) != 0)
++ {
++ /* If per-chunk unknown chunk handling is enabled use it, otherwise
++ * just write the chunks the application has set.
++ */
++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++ int keep = png_handle_as_unknown(png_ptr, up->name);
++
++ /* NOTE: this code is radically different from the read side in the
++ * matter of handling an ancillary unknown chunk. In the read side
++ * the default behavior is to discard it, in the code below the default
++ * behavior is to write it. Critical chunks are, however, only
++ * written if explicitly listed or if the default is set to write all
++ * unknown chunks.
++ *
++ * The default handling is also slightly weird - it is not possible to
++ * stop the writing of all unsafe-to-copy chunks!
++ *
++ * TODO: REVIEW: this would seem to be a bug.
++ */
++ if (keep != PNG_HANDLE_CHUNK_NEVER &&
++ ((up->name[3] & 0x20) /* safe-to-copy overrides everything */ ||
++ keep == PNG_HANDLE_CHUNK_ALWAYS ||
++ (keep == PNG_HANDLE_CHUNK_AS_DEFAULT &&
++ png_ptr->unknown_default == PNG_HANDLE_CHUNK_ALWAYS)))
++#endif
++ {
++ /* TODO: review, what is wrong with a zero length unknown chunk? */
++ if (up->size == 0)
++ png_warning(png_ptr, "Writing zero-length unknown chunk");
++
++ png_write_chunk(png_ptr, up->name, up->data, up->size);
++ }
++ }
++ }
++}
++#endif /* WRITE_UNKNOWN_CHUNKS */
++
+ /* Writes all the PNG information. This is the suggested way to use the
+ * library. If you have a new chunk to add, make a function to write it,
+ * and put it in the correct location here. If you want the chunk written
+@@ -53,21 +109,21 @@
+ * them in png_write_end(), and compressing them.
+ */
+ void PNGAPI
+-png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
++png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ png_debug(1, "in png_write_info_before_PLTE");
+
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
+- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
++ if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
+ {
+ /* Write PNG signature */
+ png_write_sig(png_ptr);
+
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+- if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) && \
+- (png_ptr->mng_features_permitted))
++ if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
++ png_ptr->mng_features_permitted != 0)
+ {
+ png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
+ png_ptr->mng_features_permitted = 0;
+@@ -79,75 +135,88 @@
+ info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
+ info_ptr->filter_type,
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+- info_ptr->interlace_type);
++ info_ptr->interlace_type
+ #else
+- 0);
++ 0
+ #endif
++ );
++
+ /* The rest of these check to see if the valid field has the appropriate
+ * flag set, and if it does, writes the chunk.
++ *
++ * 1.6.0: COLORSPACE support controls the writing of these chunks too, and
++ * the chunks will be written if the WRITE routine is there and information
++ * is available in the COLORSPACE. (See png_colorspace_sync_info in png.c
++ * for where the valid flags get set.)
++ *
++ * Under certain circumstances the colorspace can be invalidated without
++ * syncing the info_struct 'valid' flags; this happens if libpng detects and
++ * error and calls png_error while the color space is being set, yet the
++ * application continues writing the PNG. So check the 'invalid' flag here
++ * too.
+ */
+-#ifdef PNG_WRITE_gAMA_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_gAMA)
+- png_write_gAMA_fixed(png_ptr, info_ptr->gamma);
+-#endif
+-#ifdef PNG_WRITE_sRGB_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_sRGB)
+- png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
++#ifdef PNG_GAMMA_SUPPORTED
++# ifdef PNG_WRITE_gAMA_SUPPORTED
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) != 0 &&
++ (info_ptr->valid & PNG_INFO_gAMA) != 0)
++ png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma);
++# endif
+ #endif
+
+-#ifdef PNG_WRITE_iCCP_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_iCCP)
+- png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,
+- (png_charp)info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);
+-#endif
++#ifdef PNG_COLORSPACE_SUPPORTED
++ /* Write only one of sRGB or an ICC profile. If a profile was supplied
++ * and it matches one of the known sRGB ones issue a warning.
++ */
++# ifdef PNG_WRITE_iCCP_SUPPORTED
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
++ (info_ptr->valid & PNG_INFO_iCCP) != 0)
++ {
++# ifdef PNG_WRITE_sRGB_SUPPORTED
++ if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
++ png_app_warning(png_ptr,
++ "profile matches sRGB but writing iCCP instead");
++# endif
++
++ png_write_iCCP(png_ptr, info_ptr->iccp_name,
++ info_ptr->iccp_profile);
++ }
++# ifdef PNG_WRITE_sRGB_SUPPORTED
++ else
++# endif
++# endif
++
++# ifdef PNG_WRITE_sRGB_SUPPORTED
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
++ (info_ptr->valid & PNG_INFO_sRGB) != 0)
++ png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
++# endif /* WRITE_sRGB */
++#endif /* COLORSPACE */
++
+ #ifdef PNG_WRITE_sBIT_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_sBIT)
++ if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
+ png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
+ #endif
+-#ifdef PNG_WRITE_cHRM_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_cHRM)
+- png_write_cHRM_fixed(png_ptr,
+- info_ptr->x_white, info_ptr->y_white,
+- info_ptr->x_red, info_ptr->y_red,
+- info_ptr->x_green, info_ptr->y_green,
+- info_ptr->x_blue, info_ptr->y_blue);
++
++#ifdef PNG_COLORSPACE_SUPPORTED
++# ifdef PNG_WRITE_cHRM_SUPPORTED
++ if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
++ (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
++ (info_ptr->valid & PNG_INFO_cHRM) != 0)
++ png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
++# endif
+ #endif
+
+ #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+- if (info_ptr->unknown_chunks_num)
+- {
+- png_unknown_chunk *up;
++ write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
++#endif
+
+- png_debug(5, "writing extra chunks");
+-
+- for (up = info_ptr->unknown_chunks;
+- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+- up++)
+- {
+- int keep = png_handle_as_unknown(png_ptr, up->name);
+-
+- if (keep != PNG_HANDLE_CHUNK_NEVER &&
+- up->location &&
+- !(up->location & PNG_HAVE_PLTE) &&
+- !(up->location & PNG_HAVE_IDAT) &&
+- !(up->location & PNG_AFTER_IDAT) &&
+- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+- {
+- if (up->size == 0)
+- png_warning(png_ptr, "Writing zero-length unknown chunk");
+-
+- png_write_chunk(png_ptr, up->name, up->data, up->size);
+- }
+- }
+- }
+-#endif
+ png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
+ }
+ }
+
+ void PNGAPI
+-png_write_info(png_structp png_ptr, png_infop info_ptr)
++png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
+ {
+ #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+ int i;
+@@ -160,19 +229,19 @@
+
+ png_write_info_before_PLTE(png_ptr, info_ptr);
+
+- if (info_ptr->valid & PNG_INFO_PLTE)
++ if ((info_ptr->valid & PNG_INFO_PLTE) != 0)
+ png_write_PLTE(png_ptr, info_ptr->palette,
+ (png_uint_32)info_ptr->num_palette);
+
+- else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
++ else if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) !=0)
+ png_error(png_ptr, "Valid palette required for paletted images");
+
+ #ifdef PNG_WRITE_tRNS_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_tRNS)
++ if ((info_ptr->valid & PNG_INFO_tRNS) !=0)
+ {
+ #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+ /* Invert the alpha channel (in tRNS) */
+- if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
++ if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
+ info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ int j;
+@@ -186,42 +255,42 @@
+ }
+ #endif
+ #ifdef PNG_WRITE_bKGD_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_bKGD)
++ if ((info_ptr->valid & PNG_INFO_bKGD) != 0)
+ png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
+ #endif
+
+ #ifdef PNG_WRITE_hIST_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_hIST)
++ if ((info_ptr->valid & PNG_INFO_hIST) != 0)
+ png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
+ #endif
+
+ #ifdef PNG_WRITE_oFFs_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_oFFs)
++ if ((info_ptr->valid & PNG_INFO_oFFs) != 0)
+ png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
+ info_ptr->offset_unit_type);
+ #endif
+
+ #ifdef PNG_WRITE_pCAL_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_pCAL)
++ if ((info_ptr->valid & PNG_INFO_pCAL) != 0)
+ png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
+ info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
+ info_ptr->pcal_units, info_ptr->pcal_params);
+ #endif
+
+ #ifdef PNG_WRITE_sCAL_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_sCAL)
++ if ((info_ptr->valid & PNG_INFO_sCAL) != 0)
+ png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
+ info_ptr->scal_s_width, info_ptr->scal_s_height);
+ #endif /* sCAL */
+
+ #ifdef PNG_WRITE_pHYs_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_pHYs)
++ if ((info_ptr->valid & PNG_INFO_pHYs) != 0)
+ png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
+ info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
+ #endif /* pHYs */
+
+ #ifdef PNG_WRITE_tIME_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_tIME)
++ if ((info_ptr->valid & PNG_INFO_tIME) != 0)
+ {
+ png_write_tIME(png_ptr, &(info_ptr->mod_time));
+ png_ptr->mode |= PNG_WROTE_tIME;
+@@ -229,7 +298,7 @@
+ #endif /* tIME */
+
+ #ifdef PNG_WRITE_sPLT_SUPPORTED
+- if (info_ptr->valid & PNG_INFO_sPLT)
++ if ((info_ptr->valid & PNG_INFO_sPLT) != 0)
+ for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
+ png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
+ #endif /* sPLT */
+@@ -251,11 +320,14 @@
+ info_ptr->text[i].lang,
+ info_ptr->text[i].lang_key,
+ info_ptr->text[i].text);
++ /* Mark this chunk as written */
++ if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
++ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
++ else
++ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ #else
+- png_warning(png_ptr, "Unable to write international text");
++ png_warning(png_ptr, "Unable to write international text");
+ #endif
+- /* Mark this chunk as written */
+- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ }
+
+ /* If we want a compressed text chunk */
+@@ -264,13 +336,12 @@
+ #ifdef PNG_WRITE_zTXt_SUPPORTED
+ /* Write compressed chunk */
+ png_write_zTXt(png_ptr, info_ptr->text[i].key,
+- info_ptr->text[i].text, 0,
+- info_ptr->text[i].compression);
++ info_ptr->text[i].text, info_ptr->text[i].compression);
++ /* Mark this chunk as written */
++ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ #else
+ png_warning(png_ptr, "Unable to write compressed text");
+ #endif
+- /* Mark this chunk as written */
+- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ }
+
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
+@@ -291,29 +362,7 @@
+ #endif /* tEXt */
+
+ #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+- if (info_ptr->unknown_chunks_num)
+- {
+- png_unknown_chunk *up;
+-
+- png_debug(5, "writing extra chunks");
+-
+- for (up = info_ptr->unknown_chunks;
+- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+- up++)
+- {
+- int keep = png_handle_as_unknown(png_ptr, up->name);
+- if (keep != PNG_HANDLE_CHUNK_NEVER &&
+- up->location &&
+- (up->location & PNG_HAVE_PLTE) &&
+- !(up->location & PNG_HAVE_IDAT) &&
+- !(up->location & PNG_AFTER_IDAT) &&
+- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+- {
+- png_write_chunk(png_ptr, up->name, up->data, up->size);
+- }
+- }
+- }
++ write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE);
+ #endif
+ }
+
+@@ -323,16 +372,21 @@
+ * comments, I suggest writing them here, and compressing them.
+ */
+ void PNGAPI
+-png_write_end(png_structp png_ptr, png_infop info_ptr)
++png_write_end(png_structrp png_ptr, png_inforp info_ptr)
+ {
+ png_debug(1, "in png_write_end");
+
+ if (png_ptr == NULL)
+ return;
+
+- if (!(png_ptr->mode & PNG_HAVE_IDAT))
++ if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
+ png_error(png_ptr, "No IDATs written into file");
+
++#ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
++ if (png_ptr->num_palette_max > png_ptr->num_palette)
++ png_benign_error(png_ptr, "Wrote palette index exceeding num_palette");
++#endif
++
+ /* See if user wants us to write information chunks */
+ if (info_ptr != NULL)
+ {
+@@ -341,8 +395,8 @@
+ #endif
+ #ifdef PNG_WRITE_tIME_SUPPORTED
+ /* Check to see if user has supplied a time chunk */
+- if ((info_ptr->valid & PNG_INFO_tIME) &&
+- !(png_ptr->mode & PNG_WROTE_tIME))
++ if ((info_ptr->valid & PNG_INFO_tIME) != 0 &&
++ (png_ptr->mode & PNG_WROTE_tIME) == 0)
+ png_write_tIME(png_ptr, &(info_ptr->mod_time));
+
+ #endif
+@@ -363,11 +417,14 @@
+ info_ptr->text[i].lang,
+ info_ptr->text[i].lang_key,
+ info_ptr->text[i].text);
++ /* Mark this chunk as written */
++ if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
++ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
++ else
++ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ #else
+ png_warning(png_ptr, "Unable to write international text");
+ #endif
+- /* Mark this chunk as written */
+- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ }
+
+ else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
+@@ -375,13 +432,12 @@
+ #ifdef PNG_WRITE_zTXt_SUPPORTED
+ /* Write compressed chunk */
+ png_write_zTXt(png_ptr, info_ptr->text[i].key,
+- info_ptr->text[i].text, 0,
+- info_ptr->text[i].compression);
++ info_ptr->text[i].text, info_ptr->text[i].compression);
++ /* Mark this chunk as written */
++ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ #else
+ png_warning(png_ptr, "Unable to write compressed text");
+ #endif
+- /* Mark this chunk as written */
+- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
+ }
+
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
+@@ -390,37 +446,16 @@
+ /* Write uncompressed chunk */
+ png_write_tEXt(png_ptr, info_ptr->text[i].key,
+ info_ptr->text[i].text, 0);
++ /* Mark this chunk as written */
++ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ #else
+ png_warning(png_ptr, "Unable to write uncompressed text");
+ #endif
+-
+- /* Mark this chunk as written */
+- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ }
+ }
+ #endif
+ #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+- if (info_ptr->unknown_chunks_num)
+- {
+- png_unknown_chunk *up;
+-
+- png_debug(5, "writing extra chunks");
+-
+- for (up = info_ptr->unknown_chunks;
+- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+- up++)
+- {
+- int keep = png_handle_as_unknown(png_ptr, up->name);
+- if (keep != PNG_HANDLE_CHUNK_NEVER &&
+- up->location &&
+- (up->location & PNG_AFTER_IDAT) &&
+- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
+- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
+- {
+- png_write_chunk(png_ptr, up->name, up->data, up->size);
+- }
+- }
+- }
++ write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT);
+ #endif
+ }
+
+@@ -428,6 +463,7 @@
+
+ /* Write end of PNG file */
+ png_write_IEND(png_ptr);
++
+ /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
+ * and restored again in libpng-1.2.30, may cause some applications that
+ * do not set png_ptr->output_flush_fn to crash. If your application
+@@ -443,9 +479,8 @@
+ }
+
+ #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 FAR * ttime)
++png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)
+ {
+ png_debug(1, "in png_convert_from_struct_tm");
+
+@@ -474,103 +509,75 @@
+ png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
+ {
+-#ifdef PNG_USER_MEM_SUPPORTED
+- return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
+- warn_fn, NULL, NULL, NULL));
++#ifndef PNG_USER_MEM_SUPPORTED
++ png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
++ error_fn, warn_fn, NULL, NULL, NULL);
++#else
++ return png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
++ warn_fn, NULL, NULL, NULL);
+ }
+
+ /* Alternate initialize png_ptr structure, and allocate any memory needed */
+-static void png_reset_filter_heuristics(png_structp png_ptr); /* forward decl */
+-
+ PNG_FUNCTION(png_structp,PNGAPI
+ png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
+ {
+-#endif /* PNG_USER_MEM_SUPPORTED */
+- volatile int png_cleanup_needed = 0;
+-#ifdef PNG_SETJMP_SUPPORTED
+- volatile
+-#endif
+- png_structp png_ptr;
+-#ifdef PNG_SETJMP_SUPPORTED
+-#ifdef USE_FAR_KEYWORD
+- jmp_buf tmp_jmpbuf;
+-#endif
++ png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
++ error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
++#endif /* USER_MEM */
++ if (png_ptr != NULL)
++ {
++ /* Set the zlib control values to defaults; they can be overridden by the
++ * application after the struct has been created.
++ */
++ png_ptr->zbuffer_size = PNG_ZBUF_SIZE;
++
++ /* 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 = 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;
++#endif /* WRITE_COMPRESSED_TEXT */
++
++ /* This is a highly dubious configuration option; by default it is off,
++ * but it may be appropriate for private builds that are testing
++ * extensions not conformant to the current specification, or of
++ * applications that must not fail to write at all costs!
++ */
++#ifdef PNG_BENIGN_WRITE_ERRORS_SUPPORTED
++ /* In stable builds only warn if an application error can be completely
++ * handled.
++ */
++ png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
+ #endif
+
+- png_debug(1, "in png_create_write_struct");
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
+- (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
+-#else
+- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
+-#endif /* PNG_USER_MEM_SUPPORTED */
+- if (png_ptr == NULL)
+- return (NULL);
+-
+- /* Added at libpng-1.2.6 */
+-#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+- png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
+- png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
++ /* App warnings are warnings in release (or release candidate) builds but
++ * are errors during development.
++ */
++#if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
++ png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
+ #endif
+
+-#ifdef PNG_SETJMP_SUPPORTED
+-/* Applications that neglect to set up their own setjmp() and then
+- encounter a png_error() will longjmp here. Since the jmpbuf is
+- then meaningless we abort instead of returning. */
+-#ifdef USE_FAR_KEYWORD
+- if (setjmp(tmp_jmpbuf))
+-#else
+- if (setjmp(png_jmpbuf(png_ptr))) /* sets longjmp to match setjmp */
+-#endif
+-#ifdef USE_FAR_KEYWORD
+- png_memcpy(png_jmpbuf(png_ptr), tmp_jmpbuf, png_sizeof(jmp_buf));
+-#endif
+- PNG_ABORT();
+-#endif
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
+-#endif /* PNG_USER_MEM_SUPPORTED */
+- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
+-
+- if (!png_user_version_check(png_ptr, user_png_ver))
+- png_cleanup_needed = 1;
+-
+- /* Initialize zbuf - compression buffer */
+- png_ptr->zbuf_size = PNG_ZBUF_SIZE;
+-
+- if (!png_cleanup_needed)
+- {
+- png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr,
+- png_ptr->zbuf_size);
+- if (png_ptr->zbuf == NULL)
+- png_cleanup_needed = 1;
++ /* TODO: delay this, it can be done in png_init_io() (if the app doesn't
++ * do it itself) avoiding setting the default function if it is not
++ * required.
++ */
++ png_set_write_fn(png_ptr, NULL, NULL, NULL);
+ }
+
+- if (png_cleanup_needed)
+- {
+- /* Clean up PNG structure and deallocate any memory. */
+- png_free(png_ptr, png_ptr->zbuf);
+- png_ptr->zbuf = NULL;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)png_ptr,
+- (png_free_ptr)free_fn, (png_voidp)mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)png_ptr);
+-#endif
+- return (NULL);
+- }
+-
+- png_set_write_fn(png_ptr, NULL, NULL, NULL);
+-
+-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+- png_reset_filter_heuristics(png_ptr);
+-#endif
+-
+- return (png_ptr);
++ return png_ptr;
+ }
+
+
+@@ -580,7 +587,7 @@
+ * "write" the image seven times.
+ */
+ void PNGAPI
+-png_write_rows(png_structp png_ptr, png_bytepp row,
++png_write_rows(png_structrp png_ptr, png_bytepp row,
+ png_uint_32 num_rows)
+ {
+ png_uint_32 i; /* row counter */
+@@ -602,7 +609,7 @@
+ * if you are writing an interlaced image.
+ */
+ void PNGAPI
+-png_write_image(png_structp png_ptr, png_bytepp image)
++png_write_image(png_structrp png_ptr, png_bytepp image)
+ {
+ png_uint_32 i; /* row index */
+ int pass, num_pass; /* pass variables */
+@@ -632,10 +639,78 @@
+ }
+ }
+
++#ifdef PNG_MNG_FEATURES_SUPPORTED
++/* Performs intrapixel differencing */
++static void
++png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
++{
++ png_debug(1, "in png_do_write_intrapixel");
++
++ if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
++ {
++ int bytes_per_pixel;
++ png_uint_32 row_width = row_info->width;
++ if (row_info->bit_depth == 8)
++ {
++ png_bytep rp;
++ png_uint_32 i;
++
++ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
++ bytes_per_pixel = 3;
++
++ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
++ bytes_per_pixel = 4;
++
++ else
++ return;
++
++ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
++ {
++ *(rp) = (png_byte)((*rp - *(rp + 1)) & 0xff);
++ *(rp + 2) = (png_byte)((*(rp + 2) - *(rp + 1)) & 0xff);
++ }
++ }
++
++#ifdef PNG_WRITE_16BIT_SUPPORTED
++ else if (row_info->bit_depth == 16)
++ {
++ png_bytep rp;
++ png_uint_32 i;
++
++ if (row_info->color_type == PNG_COLOR_TYPE_RGB)
++ bytes_per_pixel = 6;
++
++ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
++ bytes_per_pixel = 8;
++
++ else
++ return;
++
++ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
++ {
++ png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1);
++ png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);
++ png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);
++ png_uint_32 red = (png_uint_32)((s0 - s1) & 0xffffL);
++ png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
++ *(rp ) = (png_byte)((red >> 8) & 0xff);
++ *(rp + 1) = (png_byte)(red & 0xff);
++ *(rp + 4) = (png_byte)((blue >> 8) & 0xff);
++ *(rp + 5) = (png_byte)(blue & 0xff);
++ }
++ }
++#endif /* WRITE_16BIT */
++ }
++}
++#endif /* MNG_FEATURES */
++
+ /* Called by user to write a row of image data */
+ void PNGAPI
+-png_write_row(png_structp png_ptr, png_const_bytep row)
++png_write_row(png_structrp png_ptr, png_const_bytep row)
+ {
++ /* 1.5.6: moved from png_struct to be a local structure: */
++ png_row_info row_info;
++
+ if (png_ptr == NULL)
+ return;
+
+@@ -646,44 +721,44 @@
+ if (png_ptr->row_number == 0 && png_ptr->pass == 0)
+ {
+ /* Make sure we wrote the header info */
+- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
++ if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
+ png_error(png_ptr,
+ "png_write_info was never called before png_write_row");
+
+ /* Check for transforms that have been set but were defined out */
+ #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
+- if (png_ptr->transformations & PNG_INVERT_MONO)
++ if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
+ png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
+ #endif
+
+ #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
+- if (png_ptr->transformations & PNG_FILLER)
++ if ((png_ptr->transformations & PNG_FILLER) != 0)
+ png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
+ #endif
+ #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
+ defined(PNG_READ_PACKSWAP_SUPPORTED)
+- if (png_ptr->transformations & PNG_PACKSWAP)
++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
+ png_warning(png_ptr,
+ "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
+ #endif
+
+ #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
+- if (png_ptr->transformations & PNG_PACK)
++ if ((png_ptr->transformations & PNG_PACK) != 0)
+ png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
+ #endif
+
+ #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
+- if (png_ptr->transformations & PNG_SHIFT)
++ if ((png_ptr->transformations & PNG_SHIFT) != 0)
+ png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
+ #endif
+
+ #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
+- if (png_ptr->transformations & PNG_BGR)
++ if ((png_ptr->transformations & PNG_BGR) != 0)
+ png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
+ #endif
+
+ #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
+- if (png_ptr->transformations & PNG_SWAP_BYTES)
++ if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
+ png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
+ #endif
+
+@@ -692,12 +767,13 @@
+
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* If interlaced and not interested in row, return */
+- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
++ if (png_ptr->interlaced != 0 &&
++ (png_ptr->transformations & PNG_INTERLACE) != 0)
+ {
+ switch (png_ptr->pass)
+ {
+ case 0:
+- if (png_ptr->row_number & 0x07)
++ if ((png_ptr->row_number & 0x07) != 0)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+@@ -705,7 +781,7 @@
+ break;
+
+ case 1:
+- if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
++ if ((png_ptr->row_number & 0x07) != 0 || png_ptr->width < 5)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+@@ -721,7 +797,7 @@
+ break;
+
+ case 3:
+- if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)
++ if ((png_ptr->row_number & 0x03) != 0 || png_ptr->width < 3)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+@@ -737,7 +813,7 @@
+ break;
+
+ case 5:
+- if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)
++ if ((png_ptr->row_number & 0x01) != 0 || png_ptr->width < 2)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+@@ -745,7 +821,7 @@
+ break;
+
+ case 6:
+- if (!(png_ptr->row_number & 0x01))
++ if ((png_ptr->row_number & 0x01) == 0)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+@@ -759,36 +835,31 @@
+ #endif
+
+ /* Set up row info for transformations */
+- png_ptr->row_info.color_type = png_ptr->color_type;
+- png_ptr->row_info.width = png_ptr->usr_width;
+- png_ptr->row_info.channels = png_ptr->usr_channels;
+- png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
+- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
+- png_ptr->row_info.channels);
++ row_info.color_type = png_ptr->color_type;
++ row_info.width = png_ptr->usr_width;
++ row_info.channels = png_ptr->usr_channels;
++ row_info.bit_depth = png_ptr->usr_bit_depth;
++ row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels);
++ row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
+
+- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
+- png_ptr->row_info.width);
+-
+- png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type);
+- png_debug1(3, "row_info->width = %u", png_ptr->row_info.width);
+- png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels);
+- png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth);
+- png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth);
+- png_debug1(3, "row_info->rowbytes = %lu",
+- (unsigned long)png_ptr->row_info.rowbytes);
++ png_debug1(3, "row_info->color_type = %d", row_info.color_type);
++ png_debug1(3, "row_info->width = %u", row_info.width);
++ png_debug1(3, "row_info->channels = %d", row_info.channels);
++ png_debug1(3, "row_info->bit_depth = %d", row_info.bit_depth);
++ png_debug1(3, "row_info->pixel_depth = %d", row_info.pixel_depth);
++ png_debug1(3, "row_info->rowbytes = %lu", (unsigned long)row_info.rowbytes);
+
+ /* Copy user's row into buffer, leaving room for filter byte. */
+- png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes);
++ memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes);
+
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* Handle interlacing */
+ if (png_ptr->interlaced && png_ptr->pass < 6 &&
+- (png_ptr->transformations & PNG_INTERLACE))
++ (png_ptr->transformations & PNG_INTERLACE) != 0)
+ {
+- png_do_write_interlace(&(png_ptr->row_info),
+- png_ptr->row_buf + 1, png_ptr->pass);
++ png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass);
+ /* This should always get caught above, but still ... */
+- if (!(png_ptr->row_info.width))
++ if (row_info.width == 0)
+ {
+ png_write_finish_row(png_ptr);
+ return;
+@@ -798,10 +869,17 @@
+
+ #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+ /* Handle other transformations */
+- if (png_ptr->transformations)
+- png_do_write_transformations(png_ptr);
++ if (png_ptr->transformations != 0)
++ png_do_write_transformations(png_ptr, &row_info);
+ #endif
+
++ /* At this point the row_info pixel depth must match the 'transformed' depth,
++ * which is also the output depth.
++ */
++ if (row_info.pixel_depth != png_ptr->pixel_depth ||
++ row_info.pixel_depth != png_ptr->transformed_pixel_depth)
++ png_error(png_ptr, "internal write transform logic error");
++
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+ /* Write filter_method 64 (intrapixel differencing) only if
+ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
+@@ -812,16 +890,24 @@
+ * 4. The filter_method is 64 and
+ * 5. The color_type is RGB or RGBA
+ */
+- if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
++ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
+ (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
+ {
+ /* Intrapixel differencing */
+- png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
++ png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1);
+ }
+ #endif
+
++/* Added at libpng-1.5.10 */
++#ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
++ /* Check for out-of-range palette index */
++ if (row_info.color_type == PNG_COLOR_TYPE_PALETTE &&
++ png_ptr->num_palette_max >= 0)
++ png_do_check_palette_indexes(png_ptr, &row_info);
++#endif
++
+ /* Find a filter if necessary, filter the row and write it out. */
+- png_write_find_filter(png_ptr, &(png_ptr->row_info));
++ png_write_find_filter(png_ptr, &row_info);
+
+ if (png_ptr->write_row_fn != NULL)
+ (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
+@@ -830,7 +916,7 @@
+ #ifdef PNG_WRITE_FLUSH_SUPPORTED
+ /* Set the automatic flush interval or 0 to turn flushing off */
+ void PNGAPI
+-png_set_flush(png_structp png_ptr, int nrows)
++png_set_flush(png_structrp png_ptr, int nrows)
+ {
+ png_debug(1, "in png_set_flush");
+
+@@ -842,10 +928,8 @@
+
+ /* Flush the current output buffers now */
+ void PNGAPI
+-png_write_flush(png_structp png_ptr)
++png_write_flush(png_structrp png_ptr)
+ {
+- int wrote_IDAT;
+-
+ png_debug(1, "in png_write_flush");
+
+ if (png_ptr == NULL)
+@@ -855,146 +939,41 @@
+ if (png_ptr->row_number >= png_ptr->num_rows)
+ return;
+
+- do
+- {
+- int ret;
+-
+- /* Compress the data */
+- ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
+- wrote_IDAT = 0;
+-
+- /* Check for compression errors */
+- if (ret != Z_OK)
+- {
+- if (png_ptr->zstream.msg != NULL)
+- png_error(png_ptr, png_ptr->zstream.msg);
+-
+- else
+- png_error(png_ptr, "zlib error");
+- }
+-
+- if (!(png_ptr->zstream.avail_out))
+- {
+- /* Write the IDAT and reset the zlib output buffer */
+- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+- wrote_IDAT = 1;
+- }
+- } while (wrote_IDAT == 1);
+-
+- /* If there is any data left to be output, write it into a new IDAT */
+- if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
+- {
+- /* Write the IDAT and reset the zlib output buffer */
+- png_write_IDAT(png_ptr, png_ptr->zbuf,
+- png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+- }
++ png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH);
+ png_ptr->flush_rows = 0;
+ png_flush(png_ptr);
+ }
+-#endif /* PNG_WRITE_FLUSH_SUPPORTED */
++#endif /* WRITE_FLUSH */
+
+-/* Free all memory used by the write */
+-void PNGAPI
+-png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
+-{
+- png_structp png_ptr = NULL;
+- png_infop info_ptr = NULL;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_free_ptr free_fn = NULL;
+- png_voidp mem_ptr = NULL;
++#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
++static void png_reset_filter_heuristics(png_structrp png_ptr);/* forward decl */
+ #endif
+
+- png_debug(1, "in png_destroy_write_struct");
+-
+- if (png_ptr_ptr != NULL)
+- {
+- png_ptr = *png_ptr_ptr;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- free_fn = png_ptr->free_fn;
+- mem_ptr = png_ptr->mem_ptr;
+-#endif
+- }
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- if (png_ptr != NULL)
+- {
+- free_fn = png_ptr->free_fn;
+- mem_ptr = png_ptr->mem_ptr;
+- }
+-#endif
+-
+- if (info_ptr_ptr != NULL)
+- info_ptr = *info_ptr_ptr;
+-
+- if (info_ptr != NULL)
+- {
+- if (png_ptr != NULL)
+- {
+- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+-
+-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+- if (png_ptr->num_chunk_list)
+- {
+- png_free(png_ptr, png_ptr->chunk_list);
+- png_ptr->num_chunk_list = 0;
+- }
+-#endif
+- }
+-
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
+- (png_voidp)mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)info_ptr);
+-#endif
+- *info_ptr_ptr = NULL;
+- }
+-
+- if (png_ptr != NULL)
+- {
+- png_write_destroy(png_ptr);
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
+- (png_voidp)mem_ptr);
+-#else
+- png_destroy_struct((png_voidp)png_ptr);
+-#endif
+- *png_ptr_ptr = NULL;
+- }
+-}
+-
+-
+-/* Free any memory used in png_ptr struct (old method) */
+-void /* PRIVATE */
+-png_write_destroy(png_structp png_ptr)
++/* Free any memory used in png_ptr struct without freeing the struct itself. */
++static void
++png_write_destroy(png_structrp png_ptr)
+ {
+-#ifdef PNG_SETJMP_SUPPORTED
+- jmp_buf tmp_jmp; /* Save jump buffer */
+-#endif
+- png_error_ptr error_fn;
+-#ifdef PNG_WARNINGS_SUPPORTED
+- png_error_ptr warning_fn;
+-#endif
+- png_voidp error_ptr;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_free_ptr free_fn;
+-#endif
+-
+ png_debug(1, "in png_write_destroy");
+
+ /* Free any memory zlib uses */
+- if (png_ptr->zlib_state != PNG_ZLIB_UNINITIALIZED)
++ if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
+ deflateEnd(&png_ptr->zstream);
+
+ /* Free our memory. png_free checks NULL for us. */
+- png_free(png_ptr, png_ptr->zbuf);
++ png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
+ png_free(png_ptr, png_ptr->row_buf);
++ png_ptr->row_buf = NULL;
+ #ifdef PNG_WRITE_FILTER_SUPPORTED
+ png_free(png_ptr, png_ptr->prev_row);
+ png_free(png_ptr, png_ptr->sub_row);
+ png_free(png_ptr, png_ptr->up_row);
+ png_free(png_ptr, png_ptr->avg_row);
+ png_free(png_ptr, png_ptr->paeth_row);
++ png_ptr->prev_row = NULL;
++ png_ptr->sub_row = NULL;
++ png_ptr->up_row = NULL;
++ png_ptr->avg_row = NULL;
++ png_ptr->paeth_row = NULL;
+ #endif
+
+ #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+@@ -1002,41 +981,51 @@
+ png_reset_filter_heuristics(png_ptr);
+ png_free(png_ptr, png_ptr->filter_costs);
+ png_free(png_ptr, png_ptr->inv_filter_costs);
++ png_ptr->filter_costs = NULL;
++ png_ptr->inv_filter_costs = NULL;
+ #endif
+
+-#ifdef PNG_SETJMP_SUPPORTED
+- /* Reset structure */
+- png_memcpy(tmp_jmp, png_ptr->longjmp_buffer, png_sizeof(jmp_buf));
++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
++ png_free(png_ptr, png_ptr->chunk_list);
++ png_ptr->chunk_list = NULL;
+ #endif
+
+- error_fn = png_ptr->error_fn;
+-#ifdef PNG_WARNINGS_SUPPORTED
+- warning_fn = png_ptr->warning_fn;
+-#endif
+- error_ptr = png_ptr->error_ptr;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- free_fn = png_ptr->free_fn;
+-#endif
++ /* The error handling and memory handling information is left intact at this
++ * point: the jmp_buf may still have to be freed. See png_destroy_png_struct
++ * for how this happens.
++ */
++}
+
+- png_memset(png_ptr, 0, png_sizeof(png_struct));
++/* Free all memory used by the write.
++ * In libpng 1.6.0 this API changed quietly to no longer accept a NULL value for
++ * *png_ptr_ptr. Prior to 1.6.0 it would accept such a value and it would free
++ * the passed in info_structs but it would quietly fail to free any of the data
++ * inside them. In 1.6.0 it quietly does nothing (it has to be quiet because it
++ * has no png_ptr.)
++ */
++void PNGAPI
++png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
++{
++ png_debug(1, "in png_destroy_write_struct");
+
+- png_ptr->error_fn = error_fn;
+-#ifdef PNG_WARNINGS_SUPPORTED
+- png_ptr->warning_fn = warning_fn;
+-#endif
+- png_ptr->error_ptr = error_ptr;
+-#ifdef PNG_USER_MEM_SUPPORTED
+- png_ptr->free_fn = free_fn;
+-#endif
++ if (png_ptr_ptr != NULL)
++ {
++ png_structrp png_ptr = *png_ptr_ptr;
+
+-#ifdef PNG_SETJMP_SUPPORTED
+- png_memcpy(png_ptr->longjmp_buffer, tmp_jmp, png_sizeof(jmp_buf));
+-#endif
++ if (png_ptr != NULL) /* added in libpng 1.6.0 */
++ {
++ png_destroy_info_struct(png_ptr, info_ptr_ptr);
++
++ *png_ptr_ptr = NULL;
++ png_write_destroy(png_ptr);
++ png_destroy_png_struct(png_ptr);
++ }
++ }
+ }
+
+ /* Allow the application to select one or more row filters to use. */
+ void PNGAPI
+-png_set_filter(png_structp png_ptr, int method, int filters)
++png_set_filter(png_structrp png_ptr, int method, int filters)
+ {
+ png_debug(1, "in png_set_filter");
+
+@@ -1044,7 +1033,7 @@
+ return;
+
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+- if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
++ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
+ (method == PNG_INTRAPIXEL_DIFFERENCING))
+ method = PNG_FILTER_TYPE_BASE;
+
+@@ -1056,8 +1045,9 @@
+ #ifdef PNG_WRITE_FILTER_SUPPORTED
+ case 5:
+ case 6:
+- case 7: png_warning(png_ptr, "Unknown row filter for method 0");
+-#endif /* PNG_WRITE_FILTER_SUPPORTED */
++ case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
++ /* FALL THROUGH */
++#endif /* WRITE_FILTER */
+ case PNG_FILTER_VALUE_NONE:
+ png_ptr->do_filter = PNG_FILTER_NONE; break;
+
+@@ -1078,8 +1068,8 @@
+ png_ptr->do_filter = (png_byte)filters; break;
+ #else
+ default:
+- png_warning(png_ptr, "Unknown row filter for method 0");
+-#endif /* PNG_WRITE_FILTER_SUPPORTED */
++ png_app_error(png_ptr, "Unknown row filter for method 0");
++#endif /* WRITE_FILTER */
+ }
+
+ /* If we have allocated the row_buf, this means we have already started
+@@ -1094,14 +1084,16 @@
+ if (png_ptr->row_buf != NULL)
+ {
+ #ifdef PNG_WRITE_FILTER_SUPPORTED
+- if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)
++ if ((png_ptr->do_filter & PNG_FILTER_SUB) != 0 &&
++ png_ptr->sub_row == NULL)
+ {
+ png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
+ (png_ptr->rowbytes + 1));
+ png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
+ }
+
+- if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)
++ if ((png_ptr->do_filter & PNG_FILTER_UP) != 0 &&
++ png_ptr->up_row == NULL)
+ {
+ if (png_ptr->prev_row == NULL)
+ {
+@@ -1118,7 +1110,8 @@
+ }
+ }
+
+- if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)
++ if ((png_ptr->do_filter & PNG_FILTER_AVG) != 0 &&
++ png_ptr->avg_row == NULL)
+ {
+ if (png_ptr->prev_row == NULL)
+ {
+@@ -1135,7 +1128,7 @@
+ }
+ }
+
+- if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&
++ if ((png_ptr->do_filter & PNG_FILTER_PAETH) != 0 &&
+ png_ptr->paeth_row == NULL)
+ {
+ if (png_ptr->prev_row == NULL)
+@@ -1153,7 +1146,7 @@
+ }
+
+ if (png_ptr->do_filter == PNG_NO_FILTERS)
+-#endif /* PNG_WRITE_FILTER_SUPPORTED */
++#endif /* WRITE_FILTER */
+ png_ptr->do_filter = PNG_FILTER_NONE;
+ }
+ }
+@@ -1171,7 +1164,7 @@
+ #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* GRR 970116 */
+ /* Convenience reset API. */
+ static void
+-png_reset_filter_heuristics(png_structp png_ptr)
++png_reset_filter_heuristics(png_structrp png_ptr)
+ {
+ /* Clear out any old values in the 'weights' - this must be done because if
+ * the app calls set_filter_heuristics multiple times with different
+@@ -1204,7 +1197,7 @@
+ }
+
+ static int
+-png_init_filter_heuristics(png_structp png_ptr, int heuristic_method,
++png_init_filter_heuristics(png_structrp png_ptr, int heuristic_method,
+ int num_weights)
+ {
+ if (png_ptr == NULL)
+@@ -1224,7 +1217,7 @@
+ if (num_weights > 0)
+ {
+ png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
+- (png_uint_32)(png_sizeof(png_byte) * num_weights));
++ (png_uint_32)((sizeof (png_byte)) * num_weights));
+
+ /* To make sure that the weighting starts out fairly */
+ for (i = 0; i < num_weights; i++)
+@@ -1233,10 +1226,10 @@
+ }
+
+ png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
+- (png_uint_32)(png_sizeof(png_uint_16) * num_weights));
++ (png_uint_32)((sizeof (png_uint_16)) * num_weights));
+
+ png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
+- (png_uint_32)(png_sizeof(png_uint_16) * num_weights));
++ (png_uint_32)((sizeof (png_uint_16)) * num_weights));
+
+ for (i = 0; i < num_weights; i++)
+ {
+@@ -1254,10 +1247,10 @@
+ if (png_ptr->filter_costs == NULL)
+ {
+ png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
+- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
++ (png_uint_32)((sizeof (png_uint_16)) * PNG_FILTER_VALUE_LAST));
+
+ png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
+- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
++ (png_uint_32)((sizeof (png_uint_16)) * PNG_FILTER_VALUE_LAST));
+ }
+
+ for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
+@@ -1287,7 +1280,7 @@
+ /* Provide floating and fixed point APIs */
+ #ifdef PNG_FLOATING_POINT_SUPPORTED
+ void PNGAPI
+-png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
++png_set_filter_heuristics(png_structrp png_ptr, int heuristic_method,
+ int num_weights, png_const_doublep filter_weights,
+ png_const_doublep filter_costs)
+ {
+@@ -1296,7 +1289,7 @@
+ /* The internal API allocates all the arrays and ensures that the elements of
+ * those arrays are set to the default value.
+ */
+- if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights))
++ if (png_init_filter_heuristics(png_ptr, heuristic_method, num_weights) == 0)
+ return;
+
+ /* If using the weighted method copy in the weights. */
+@@ -1342,7 +1335,7 @@
+
+ #ifdef PNG_FIXED_POINT_SUPPORTED
+ void PNGAPI
+-png_set_filter_heuristics_fixed(png_structp png_ptr, int heuristic_method,
++png_set_filter_heuristics_fixed(png_structrp png_ptr, int heuristic_method,
+ int num_weights, png_const_fixed_point_p filter_weights,
+ png_const_fixed_point_p filter_costs)
+ {
+@@ -1351,7 +1344,7 @@
+ /* The internal API allocates all the arrays and ensures that the elements of
+ * those arrays are set to the default value.
+ */
+- if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights))
++ if (png_init_filter_heuristics(png_ptr, heuristic_method, num_weights) == 0)
+ return;
+
+ /* If using the weighted method copy in the weights. */
+@@ -1405,40 +1398,40 @@
+ }
+ }
+ #endif /* FIXED_POINT */
+-#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
++#endif /* WRITE_WEIGHTED_FILTER */
+
+ void PNGAPI
+-png_set_compression_level(png_structp png_ptr, int level)
++png_set_compression_level(png_structrp png_ptr, int level)
+ {
+ png_debug(1, "in png_set_compression_level");
+
+ if (png_ptr == NULL)
+ return;
+
+- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
+ png_ptr->zlib_level = level;
+ }
+
+ void PNGAPI
+-png_set_compression_mem_level(png_structp png_ptr, int mem_level)
++png_set_compression_mem_level(png_structrp png_ptr, int mem_level)
+ {
+ png_debug(1, "in png_set_compression_mem_level");
+
+ if (png_ptr == NULL)
+ return;
+
+- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
+ png_ptr->zlib_mem_level = mem_level;
+ }
+
+ void PNGAPI
+-png_set_compression_strategy(png_structp png_ptr, int strategy)
++png_set_compression_strategy(png_structrp png_ptr, int strategy)
+ {
+ png_debug(1, "in png_set_compression_strategy");
+
+ if (png_ptr == NULL)
+ return;
+
++ /* The flag setting here prevents the libpng dynamic selection of strategy.
++ */
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
+ png_ptr->zlib_strategy = strategy;
+ }
+@@ -1447,80 +1440,81 @@
+ * smaller value of window_bits if it can do so safely.
+ */
+ void PNGAPI
+-png_set_compression_window_bits(png_structp png_ptr, int window_bits)
++png_set_compression_window_bits(png_structrp png_ptr, int window_bits)
+ {
+ if (png_ptr == NULL)
+ return;
+
++ /* Prior to 1.6.0 this would warn but then set the window_bits value, this
++ * meant that negative window bits values could be selected which would cause
++ * libpng to write a non-standard PNG file with raw deflate or gzip
++ * compressed IDAT or ancillary chunks. Such files can be read and there is
++ * no warning on read, so this seems like a very bad idea.
++ */
+ if (window_bits > 15)
++ {
+ png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
++ window_bits = 15;
++ }
+
+ else if (window_bits < 8)
++ {
+ png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
++ window_bits = 8;
++ }
+
+-#ifndef WBITS_8_OK
+- /* Avoid libpng bug with 256-byte windows */
+- if (window_bits == 8)
+- {
+- png_warning(png_ptr, "Compression window is being reset to 512");
+- window_bits = 9;
+- }
+-
+-#endif
+- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
+ png_ptr->zlib_window_bits = window_bits;
+ }
+
+ void PNGAPI
+-png_set_compression_method(png_structp png_ptr, int method)
++png_set_compression_method(png_structrp png_ptr, int method)
+ {
+ png_debug(1, "in png_set_compression_method");
+
+ if (png_ptr == NULL)
+ return;
+
++ /* This would produce an invalid PNG file if it worked, but it doesn't and
++ * deflate will fault it, so it is harmless to just warn here.
++ */
+ if (method != 8)
+ png_warning(png_ptr, "Only compression method 8 is supported by PNG");
+
+- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;
+ png_ptr->zlib_method = method;
+ }
+
+ /* The following were added to libpng-1.5.4 */
+ #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+ void PNGAPI
+-png_set_text_compression_level(png_structp png_ptr, int level)
++png_set_text_compression_level(png_structrp png_ptr, int level)
+ {
+ png_debug(1, "in png_set_text_compression_level");
+
+ if (png_ptr == NULL)
+ return;
+
+- png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_LEVEL;
+ png_ptr->zlib_text_level = level;
+ }
+
+ void PNGAPI
+-png_set_text_compression_mem_level(png_structp png_ptr, int mem_level)
++png_set_text_compression_mem_level(png_structrp png_ptr, int mem_level)
+ {
+ png_debug(1, "in png_set_text_compression_mem_level");
+
+ if (png_ptr == NULL)
+ return;
+
+- png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_MEM_LEVEL;
+ png_ptr->zlib_text_mem_level = mem_level;
+ }
+
+ void PNGAPI
+-png_set_text_compression_strategy(png_structp png_ptr, int strategy)
++png_set_text_compression_strategy(png_structrp png_ptr, int strategy)
+ {
+ png_debug(1, "in png_set_text_compression_strategy");
+
+ if (png_ptr == NULL)
+ return;
+
+- png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_STRATEGY;
+ png_ptr->zlib_text_strategy = strategy;
+ }
+
+@@ -1528,32 +1522,28 @@
+ * smaller value of window_bits if it can do so safely.
+ */
+ void PNGAPI
+-png_set_text_compression_window_bits(png_structp png_ptr, int window_bits)
++png_set_text_compression_window_bits(png_structrp png_ptr, int window_bits)
+ {
+ if (png_ptr == NULL)
+ return;
+
+ if (window_bits > 15)
++ {
+ png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
++ window_bits = 15;
++ }
+
+ else if (window_bits < 8)
++ {
+ png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
++ window_bits = 8;
++ }
+
+-#ifndef WBITS_8_OK
+- /* Avoid libpng bug with 256-byte windows */
+- if (window_bits == 8)
+- {
+- png_warning(png_ptr, "Text compression window is being reset to 512");
+- window_bits = 9;
+- }
+-
+-#endif
+- png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_WINDOW_BITS;
+ png_ptr->zlib_text_window_bits = window_bits;
+ }
+
+ void PNGAPI
+-png_set_text_compression_method(png_structp png_ptr, int method)
++png_set_text_compression_method(png_structrp png_ptr, int method)
+ {
+ png_debug(1, "in png_set_text_compression_method");
+
+@@ -1563,14 +1553,13 @@
+ if (method != 8)
+ png_warning(png_ptr, "Only compression method 8 is supported by PNG");
+
+- png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_METHOD;
+ png_ptr->zlib_text_method = method;
+ }
+-#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */
++#endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
+ /* end of API added to libpng-1.5.4 */
+
+ void PNGAPI
+-png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
++png_set_write_status_fn(png_structrp png_ptr, png_write_status_ptr write_row_fn)
+ {
+ if (png_ptr == NULL)
+ return;
+@@ -1580,7 +1569,7 @@
+
+ #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+ void PNGAPI
+-png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
++png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr
+ write_user_transform_fn)
+ {
+ png_debug(1, "in png_set_write_user_transform_fn");
+@@ -1596,88 +1585,899 @@
+
+ #ifdef PNG_INFO_IMAGE_SUPPORTED
+ void PNGAPI
+-png_write_png(png_structp png_ptr, png_infop info_ptr,
++png_write_png(png_structrp png_ptr, png_inforp info_ptr,
+ int transforms, voidp params)
+ {
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
++ if ((info_ptr->valid & PNG_INFO_IDAT) == 0)
++ {
++ png_app_error(png_ptr, "no rows for png_write_image to write");
++ return;
++ }
++
+ /* Write the file header information. */
+ png_write_info(png_ptr, info_ptr);
+
+ /* ------ these transformations don't touch the info structure ------- */
+
++ /* Invert monochrome pixels */
++ if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0)
+ #ifdef PNG_WRITE_INVERT_SUPPORTED
+- /* Invert monochrome pixels */
+- if (transforms & PNG_TRANSFORM_INVERT_MONO)
+ png_set_invert_mono(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
+ #endif
+
+-#ifdef PNG_WRITE_SHIFT_SUPPORTED
+ /* Shift the pixels up to a legal bit depth and fill in
+ * as appropriate to correctly scale the image.
+ */
+- if ((transforms & PNG_TRANSFORM_SHIFT)
+- && (info_ptr->valid & PNG_INFO_sBIT))
+- png_set_shift(png_ptr, &info_ptr->sig_bit);
++ if ((transforms & PNG_TRANSFORM_SHIFT) != 0)
++#ifdef PNG_WRITE_SHIFT_SUPPORTED
++ if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
++ png_set_shift(png_ptr, &info_ptr->sig_bit);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
+ #endif
+
++ /* Pack pixels into bytes */
++ if ((transforms & PNG_TRANSFORM_PACKING) != 0)
+ #ifdef PNG_WRITE_PACK_SUPPORTED
+- /* Pack pixels into bytes */
+- if (transforms & PNG_TRANSFORM_PACKING)
+- png_set_packing(png_ptr);
++ png_set_packing(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
+ #endif
+
++ /* Swap location of alpha bytes from ARGB to RGBA */
++ if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0)
+ #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+- /* Swap location of alpha bytes from ARGB to RGBA */
+- if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
+ png_set_swap_alpha(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
+ #endif
+
++ /* Remove a filler (X) from XRGB/RGBX/AG/GA into to convert it into
++ * RGB, note that the code expects the input color type to be G or RGB; no
++ * alpha channel.
++ */
++ if ((transforms & (PNG_TRANSFORM_STRIP_FILLER_AFTER|
++ PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0)
++ {
+ #ifdef PNG_WRITE_FILLER_SUPPORTED
+- /* Pack XRGB/RGBX/ARGB/RGBA into RGB (4 channels -> 3 channels) */
+- if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)
+- png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
++ if ((transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) != 0)
++ {
++ if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
++ png_app_error(png_ptr,
++ "PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported");
+
+- else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)
+- png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
++ /* Continue if ignored - this is the pre-1.6.10 behavior */
++ png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
++ }
++
++ else if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
++ png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_FILLER not supported");
++#endif
++ }
++
++ /* Flip BGR pixels to RGB */
++ if ((transforms & PNG_TRANSFORM_BGR) != 0)
++#ifdef PNG_WRITE_BGR_SUPPORTED
++ png_set_bgr(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
+ #endif
+
+-#ifdef PNG_WRITE_BGR_SUPPORTED
+- /* Flip BGR pixels to RGB */
+- if (transforms & PNG_TRANSFORM_BGR)
+- png_set_bgr(png_ptr);
++ /* Swap bytes of 16-bit files to most significant byte first */
++ if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0)
++#ifdef PNG_WRITE_SWAP_SUPPORTED
++ png_set_swap(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
+ #endif
+
+-#ifdef PNG_WRITE_SWAP_SUPPORTED
+- /* Swap bytes of 16-bit files to most significant byte first */
+- if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
+- png_set_swap(png_ptr);
++ /* Swap bits of 1, 2, 4 bit packed pixel formats */
++ if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0)
++#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
++ png_set_packswap(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
+ #endif
+
+-#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
+- /* Swap bits of 1, 2, 4 bit packed pixel formats */
+- if (transforms & PNG_TRANSFORM_PACKSWAP)
+- png_set_packswap(png_ptr);
+-#endif
+-
++ /* Invert the alpha channel from opacity to transparency */
++ if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0)
+ #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+- /* Invert the alpha channel from opacity to transparency */
+- if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
+ png_set_invert_alpha(png_ptr);
++#else
++ png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
+ #endif
+
+ /* ----------------------- end of transformations ------------------- */
+
+ /* Write the bits */
+- if (info_ptr->valid & PNG_INFO_IDAT)
+- png_write_image(png_ptr, info_ptr->row_pointers);
++ png_write_image(png_ptr, info_ptr->row_pointers);
+
+ /* It is REQUIRED to call this to finish writing the rest of the file */
+ png_write_end(png_ptr, info_ptr);
+
+- PNG_UNUSED(transforms) /* Quiet compiler warnings */
+ PNG_UNUSED(params)
+ }
+ #endif
+-#endif /* PNG_WRITE_SUPPORTED */
++
++
++#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
++#ifdef PNG_STDIO_SUPPORTED /* currently required for png_image_write_* */
++/* Initialize the write structure - general purpose utility. */
++static int
++png_image_write_init(png_imagep image)
++{
++ png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image,
++ png_safe_error, png_safe_warning);
++
++ if (png_ptr != NULL)
++ {
++ png_infop info_ptr = png_create_info_struct(png_ptr);
++
++ if (info_ptr != NULL)
++ {
++ png_controlp control = png_voidcast(png_controlp,
++ png_malloc_warn(png_ptr, (sizeof *control)));
++
++ if (control != NULL)
++ {
++ memset(control, 0, (sizeof *control));
++
++ control->png_ptr = png_ptr;
++ control->info_ptr = info_ptr;
++ control->for_write = 1;
++
++ image->opaque = control;
++ return 1;
++ }
++
++ /* Error clean up */
++ png_destroy_info_struct(png_ptr, &info_ptr);
++ }
++
++ png_destroy_write_struct(&png_ptr, NULL);
++ }
++
++ return png_image_error(image, "png_image_write_: out of memory");
++}
++
++/* Arguments to png_image_write_main: */
++typedef struct
++{
++ /* Arguments: */
++ png_imagep image;
++ png_const_voidp buffer;
++ png_int_32 row_stride;
++ png_const_voidp colormap;
++ int convert_to_8bit;
++ /* Local variables: */
++ png_const_voidp first_row;
++ ptrdiff_t row_bytes;
++ png_voidp local_row;
++} png_image_write_control;
++
++/* Write png_uint_16 input to a 16-bit PNG; the png_ptr has already been set to
++ * do any necessary byte swapping. The component order is defined by the
++ * png_image format value.
++ */
++static int
++png_write_image_16bit(png_voidp argument)
++{
++ png_image_write_control *display = png_voidcast(png_image_write_control*,
++ argument);
++ png_imagep image = display->image;
++ png_structrp png_ptr = image->opaque->png_ptr;
++
++ png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
++ display->first_row);
++ png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row);
++ png_uint_16p row_end;
++ const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
++ int aindex = 0;
++ png_uint_32 y = image->height;
++
++ if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
++ if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
++ {
++ aindex = -1;
++ ++input_row; /* To point to the first component */
++ ++output_row;
++ }
++
++ else
++# endif
++ aindex = channels;
++ }
++
++ else
++ png_error(png_ptr, "png_write_image: internal call error");
++
++ /* Work out the output row end and count over this, note that the increment
++ * above to 'row' means that row_end can actually be beyond the end of the
++ * row; this is correct.
++ */
++ row_end = output_row + image->width * (channels+1);
++
++ while (y-- > 0)
++ {
++ png_const_uint_16p in_ptr = input_row;
++ png_uint_16p out_ptr = output_row;
++
++ while (out_ptr < row_end)
++ {
++ const png_uint_16 alpha = in_ptr[aindex];
++ png_uint_32 reciprocal = 0;
++ int c;
++
++ out_ptr[aindex] = alpha;
++
++ /* Calculate a reciprocal. The correct calculation is simply
++ * component/alpha*65535 << 15. (I.e. 15 bits of precision); this
++ * allows correct rounding by adding .5 before the shift. 'reciprocal'
++ * is only initialized when required.
++ */
++ if (alpha > 0 && alpha < 65535)
++ reciprocal = ((0xffff<<15)+(alpha>>1))/alpha;
++
++ c = channels;
++ do /* always at least one channel */
++ {
++ png_uint_16 component = *in_ptr++;
++
++ /* The following gives 65535 for an alpha of 0, which is fine,
++ * otherwise if 0/0 is represented as some other value there is more
++ * likely to be a discontinuity which will probably damage
++ * compression when moving from a fully transparent area to a
++ * nearly transparent one. (The assumption here is that opaque
++ * areas tend not to be 0 intensity.)
++ */
++ if (component >= alpha)
++ component = 65535;
++
++ /* component<alpha, so component/alpha is less than one and
++ * component*reciprocal is less than 2^31.
++ */
++ else if (component > 0 && alpha < 65535)
++ {
++ png_uint_32 calc = component * reciprocal;
++ calc += 16384; /* round to nearest */
++ component = (png_uint_16)(calc >> 15);
++ }
++
++ *out_ptr++ = component;
++ }
++ while (--c > 0);
++
++ /* Skip to next component (skip the intervening alpha channel) */
++ ++in_ptr;
++ ++out_ptr;
++ }
++
++ png_write_row(png_ptr, png_voidcast(png_const_bytep, display->local_row));
++ input_row += display->row_bytes/(sizeof (png_uint_16));
++ }
++
++ return 1;
++}
++
++/* Given 16-bit input (1 to 4 channels) write 8-bit output. If an alpha channel
++ * is present it must be removed from the components, the components are then
++ * written in sRGB encoding. No components are added or removed.
++ *
++ * Calculate an alpha reciprocal to reverse pre-multiplication. As above the
++ * calculation can be done to 15 bits of accuracy; however, the output needs to
++ * be scaled in the range 0..255*65535, so include that scaling here.
++ */
++#define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
++
++static png_byte
++png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
++ png_uint_32 reciprocal/*from the above macro*/)
++{
++ /* The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0
++ * is represented as some other value there is more likely to be a
++ * discontinuity which will probably damage compression when moving from a
++ * fully transparent area to a nearly transparent one. (The assumption here
++ * is that opaque areas tend not to be 0 intensity.)
++ *
++ * There is a rounding problem here; if alpha is less than 128 it will end up
++ * as 0 when scaled to 8 bits. To avoid introducing spurious colors into the
++ * output change for this too.
++ */
++ if (component >= alpha || alpha < 128)
++ return 255;
++
++ /* component<alpha, so component/alpha is less than one and
++ * component*reciprocal is less than 2^31.
++ */
++ else if (component > 0)
++ {
++ /* The test is that alpha/257 (rounded) is less than 255, the first value
++ * that becomes 255 is 65407.
++ * NOTE: this must agree with the PNG_DIV257 macro (which must, therefore,
++ * be exact!) [Could also test reciprocal != 0]
++ */
++ if (alpha < 65407)
++ {
++ component *= reciprocal;
++ component += 64; /* round to nearest */
++ component >>= 7;
++ }
++
++ else
++ component *= 255;
++
++ /* Convert the component to sRGB. */
++ return (png_byte)PNG_sRGB_FROM_LINEAR(component);
++ }
++
++ else
++ return 0;
++}
++
++static int
++png_write_image_8bit(png_voidp argument)
++{
++ png_image_write_control *display = png_voidcast(png_image_write_control*,
++ argument);
++ png_imagep image = display->image;
++ png_structrp png_ptr = image->opaque->png_ptr;
++
++ png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
++ display->first_row);
++ png_bytep output_row = png_voidcast(png_bytep, display->local_row);
++ png_uint_32 y = image->height;
++ const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
++
++ if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ {
++ png_bytep row_end;
++ int aindex;
++
++# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
++ if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
++ {
++ aindex = -1;
++ ++input_row; /* To point to the first component */
++ ++output_row;
++ }
++
++ else
++# endif
++ aindex = channels;
++
++ /* Use row_end in place of a loop counter: */
++ row_end = output_row + image->width * (channels+1);
++
++ while (y-- > 0)
++ {
++ png_const_uint_16p in_ptr = input_row;
++ png_bytep out_ptr = output_row;
++
++ while (out_ptr < row_end)
++ {
++ png_uint_16 alpha = in_ptr[aindex];
++ png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
++ png_uint_32 reciprocal = 0;
++ int c;
++
++ /* Scale and write the alpha channel. */
++ out_ptr[aindex] = alphabyte;
++
++ if (alphabyte > 0 && alphabyte < 255)
++ reciprocal = UNP_RECIPROCAL(alpha);
++
++ c = channels;
++ do /* always at least one channel */
++ *out_ptr++ = png_unpremultiply(*in_ptr++, alpha, reciprocal);
++ while (--c > 0);
++
++ /* Skip to next component (skip the intervening alpha channel) */
++ ++in_ptr;
++ ++out_ptr;
++ } /* while out_ptr < row_end */
++
++ png_write_row(png_ptr, png_voidcast(png_const_bytep,
++ display->local_row));
++ input_row += display->row_bytes/(sizeof (png_uint_16));
++ } /* while y */
++ }
++
++ else
++ {
++ /* No alpha channel, so the row_end really is the end of the row and it
++ * is sufficient to loop over the components one by one.
++ */
++ png_bytep row_end = output_row + image->width * channels;
++
++ while (y-- > 0)
++ {
++ png_const_uint_16p in_ptr = input_row;
++ png_bytep out_ptr = output_row;
++
++ while (out_ptr < row_end)
++ {
++ png_uint_32 component = *in_ptr++;
++
++ component *= 255;
++ *out_ptr++ = (png_byte)PNG_sRGB_FROM_LINEAR(component);
++ }
++
++ png_write_row(png_ptr, output_row);
++ input_row += display->row_bytes/(sizeof (png_uint_16));
++ }
++ }
++
++ return 1;
++}
++
++static void
++png_image_set_PLTE(png_image_write_control *display)
++{
++ const png_imagep image = display->image;
++ const void *cmap = display->colormap;
++ const int entries = image->colormap_entries > 256 ? 256 :
++ (int)image->colormap_entries;
++
++ /* NOTE: the caller must check for cmap != NULL and entries != 0 */
++ const png_uint_32 format = image->format;
++ const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format);
++
++# if defined(PNG_FORMAT_BGR_SUPPORTED) &&\
++ defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED)
++ const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
++ (format & PNG_FORMAT_FLAG_ALPHA) != 0;
++# else
++# define afirst 0
++# endif
++
++# ifdef PNG_FORMAT_BGR_SUPPORTED
++ const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
++# else
++# define bgr 0
++# endif
++
++ int i, num_trans;
++ png_color palette[256];
++ png_byte tRNS[256];
++
++ memset(tRNS, 255, (sizeof tRNS));
++ memset(palette, 0, (sizeof palette));
++
++ for (i=num_trans=0; i<entries; ++i)
++ {
++ /* This gets automatically converted to sRGB with reversal of the
++ * pre-multiplication if the color-map has an alpha channel.
++ */
++ if ((format & PNG_FORMAT_FLAG_LINEAR) != 0)
++ {
++ png_const_uint_16p entry = png_voidcast(png_const_uint_16p, cmap);
++
++ entry += i * channels;
++
++ if ((channels & 1) != 0) /* no alpha */
++ {
++ if (channels >= 3) /* RGB */
++ {
++ palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
++ entry[(2 ^ bgr)]);
++ palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
++ entry[1]);
++ palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
++ entry[bgr]);
++ }
++
++ else /* Gray */
++ palette[i].blue = palette[i].red = palette[i].green =
++ (png_byte)PNG_sRGB_FROM_LINEAR(255 * *entry);
++ }
++
++ else /* alpha */
++ {
++ png_uint_16 alpha = entry[afirst ? 0 : channels-1];
++ png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
++ png_uint_32 reciprocal = 0;
++
++ /* Calculate a reciprocal, as in the png_write_image_8bit code above
++ * this is designed to produce a value scaled to 255*65535 when
++ * divided by 128 (i.e. asr 7).
++ */
++ if (alphabyte > 0 && alphabyte < 255)
++ reciprocal = (((0xffff*0xff)<<7)+(alpha>>1))/alpha;
++
++ tRNS[i] = alphabyte;
++ if (alphabyte < 255)
++ num_trans = i+1;
++
++ if (channels >= 3) /* RGB */
++ {
++ palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)],
++ alpha, reciprocal);
++ palette[i].green = png_unpremultiply(entry[afirst + 1], alpha,
++ reciprocal);
++ palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha,
++ reciprocal);
++ }
++
++ else /* gray */
++ palette[i].blue = palette[i].red = palette[i].green =
++ png_unpremultiply(entry[afirst], alpha, reciprocal);
++ }
++ }
++
++ else /* Color-map has sRGB values */
++ {
++ png_const_bytep entry = png_voidcast(png_const_bytep, cmap);
++
++ entry += i * channels;
++
++ switch (channels)
++ {
++ case 4:
++ tRNS[i] = entry[afirst ? 0 : 3];
++ if (tRNS[i] < 255)
++ num_trans = i+1;
++ /* FALL THROUGH */
++ case 3:
++ palette[i].blue = entry[afirst + (2 ^ bgr)];
++ palette[i].green = entry[afirst + 1];
++ palette[i].red = entry[afirst + bgr];
++ break;
++
++ case 2:
++ tRNS[i] = entry[1 ^ afirst];
++ if (tRNS[i] < 255)
++ num_trans = i+1;
++ /* FALL THROUGH */
++ case 1:
++ palette[i].blue = palette[i].red = palette[i].green =
++ entry[afirst];
++ break;
++
++ default:
++ break;
++ }
++ }
++ }
++
++# ifdef afirst
++# undef afirst
++# endif
++# ifdef bgr
++# undef bgr
++# endif
++
++ png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette,
++ entries);
++
++ if (num_trans > 0)
++ png_set_tRNS(image->opaque->png_ptr, image->opaque->info_ptr, tRNS,
++ num_trans, NULL);
++
++ image->colormap_entries = entries;
++}
++
++static int
++png_image_write_main(png_voidp argument)
++{
++ png_image_write_control *display = png_voidcast(png_image_write_control*,
++ argument);
++ png_imagep image = display->image;
++ png_structrp png_ptr = image->opaque->png_ptr;
++ png_inforp info_ptr = image->opaque->info_ptr;
++ png_uint_32 format = image->format;
++
++ /* The following four ints are actually booleans */
++ int colormap = (format & PNG_FORMAT_FLAG_COLORMAP);
++ int linear = !colormap && (format & PNG_FORMAT_FLAG_LINEAR); /* input */
++ int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA);
++ int write_16bit = linear && !colormap && (display->convert_to_8bit == 0);
++
++# ifdef PNG_BENIGN_ERRORS_SUPPORTED
++ /* Make sure we error out on any bad situation */
++ png_set_benign_errors(png_ptr, 0/*error*/);
++# endif
++
++ /* Default the 'row_stride' parameter if required. */
++ if (display->row_stride == 0)
++ display->row_stride = PNG_IMAGE_ROW_STRIDE(*image);
++
++ /* Set the required transforms then write the rows in the correct order. */
++ if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0)
++ {
++ if (display->colormap != NULL && image->colormap_entries > 0)
++ {
++ png_uint_32 entries = image->colormap_entries;
++
++ png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
++ entries > 16 ? 8 : (entries > 4 ? 4 : (entries > 2 ? 2 : 1)),
++ PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
++ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
++
++ png_image_set_PLTE(display);
++ }
++
++ else
++ png_error(image->opaque->png_ptr,
++ "no color-map for color-mapped image");
++ }
++
++ else
++ png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
++ write_16bit ? 16 : 8,
++ ((format & PNG_FORMAT_FLAG_COLOR) ? PNG_COLOR_MASK_COLOR : 0) +
++ ((format & PNG_FORMAT_FLAG_ALPHA) ? PNG_COLOR_MASK_ALPHA : 0),
++ PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
++
++ /* Counter-intuitively the data transformations must be called *after*
++ * png_write_info, not before as in the read code, but the 'set' functions
++ * must still be called before. Just set the color space information, never
++ * write an interlaced image.
++ */
++
++ if (write_16bit != 0)
++ {
++ /* The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB. */
++ png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_LINEAR);
++
++ if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
++ png_set_cHRM_fixed(png_ptr, info_ptr,
++ /* color x y */
++ /* white */ 31270, 32900,
++ /* red */ 64000, 33000,
++ /* green */ 30000, 60000,
++ /* blue */ 15000, 6000
++ );
++ }
++
++ else if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
++ png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
++
++ /* Else writing an 8-bit file and the *colors* aren't sRGB, but the 8-bit
++ * space must still be gamma encoded.
++ */
++ else
++ png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_sRGB_INVERSE);
++
++ /* Write the file header. */
++ png_write_info(png_ptr, info_ptr);
++
++ /* Now set up the data transformations (*after* the header is written),
++ * remove the handled transformations from the 'format' flags for checking.
++ *
++ * First check for a little endian system if writing 16 bit files.
++ */
++ if (write_16bit != 0)
++ {
++ PNG_CONST png_uint_16 le = 0x0001;
++
++ if ((*(png_const_bytep) & le) != 0)
++ png_set_swap(png_ptr);
++ }
++
++# ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
++ if ((format & PNG_FORMAT_FLAG_BGR) != 0)
++ {
++ if (colormap == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0)
++ png_set_bgr(png_ptr);
++ format &= ~PNG_FORMAT_FLAG_BGR;
++ }
++# endif
++
++# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
++ if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
++ {
++ if (colormap == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0)
++ png_set_swap_alpha(png_ptr);
++ format &= ~PNG_FORMAT_FLAG_AFIRST;
++ }
++# endif
++
++ /* If there are 16 or fewer color-map entries we wrote a lower bit depth
++ * above, but the application data is still byte packed.
++ */
++ if (colormap != 0 && image->colormap_entries <= 16)
++ png_set_packing(png_ptr);
++
++ /* That should have handled all (both) the transforms. */
++ if ((format & ~(png_uint_32)(PNG_FORMAT_FLAG_COLOR | PNG_FORMAT_FLAG_LINEAR |
++ PNG_FORMAT_FLAG_ALPHA | PNG_FORMAT_FLAG_COLORMAP)) != 0)
++ png_error(png_ptr, "png_write_image: unsupported transformation");
++
++ {
++ png_const_bytep row = png_voidcast(png_const_bytep, display->buffer);
++ ptrdiff_t row_bytes = display->row_stride;
++
++ if (linear != 0)
++ row_bytes *= (sizeof (png_uint_16));
++
++ if (row_bytes < 0)
++ row += (image->height-1) * (-row_bytes);
++
++ display->first_row = row;
++ display->row_bytes = row_bytes;
++ }
++
++ /* Apply 'fast' options if the flag is set. */
++ if ((image->flags & PNG_IMAGE_FLAG_FAST) != 0)
++ {
++ png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_NO_FILTERS);
++ /* NOTE: determined by experiment using pngstest, this reflects some
++ * balance between the time to write the image once and the time to read
++ * it about 50 times. The speed-up in pngstest was about 10-20% of the
++ * total (user) time on a heavily loaded system.
++ */
++ png_set_compression_level(png_ptr, 3);
++ }
++
++ /* Check for the cases that currently require a pre-transform on the row
++ * before it is written. This only applies when the input is 16-bit and
++ * either there is an alpha channel or it is converted to 8-bit.
++ */
++ if ((linear != 0 && alpha != 0 ) ||
++ (colormap == 0 && display->convert_to_8bit != 0))
++ {
++ png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr,
++ png_get_rowbytes(png_ptr, info_ptr)));
++ int result;
++
++ display->local_row = row;
++ if (write_16bit != 0)
++ result = png_safe_execute(image, png_write_image_16bit, display);
++ else
++ result = png_safe_execute(image, png_write_image_8bit, display);
++ display->local_row = NULL;
++
++ png_free(png_ptr, row);
++
++ /* Skip the 'write_end' on error: */
++ if (result == 0)
++ return 0;
++ }
++
++ /* Otherwise this is the case where the input is in a format currently
++ * supported by the rest of the libpng write code; call it directly.
++ */
++ else
++ {
++ png_const_bytep row = png_voidcast(png_const_bytep, display->first_row);
++ ptrdiff_t row_bytes = display->row_bytes;
++ png_uint_32 y = image->height;
++
++ while (y-- > 0)
++ {
++ png_write_row(png_ptr, row);
++ row += row_bytes;
++ }
++ }
++
++ png_write_end(png_ptr, info_ptr);
++ return 1;
++}
++
++int PNGAPI
++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 (file != NULL)
++ {
++ if (png_image_write_init(image) != 0)
++ {
++ png_image_write_control display;
++ int result;
++
++ /* This is slightly evil, but png_init_io doesn't do anything other
++ * than this and we haven't changed the standard IO functions so
++ * this saves a 'safe' function.
++ */
++ image->opaque->png_ptr->io_ptr = file;
++
++ memset(&display, 0, (sizeof display));
++ display.image = image;
++ display.buffer = buffer;
++ display.row_stride = row_stride;
++ display.colormap = colormap;
++ display.convert_to_8bit = convert_to_8bit;
++
++ result = png_safe_execute(image, png_image_write_main, &display);
++ png_image_free(image);
++ return result;
++ }
++
++ else
++ return 0;
++ }
++
++ else
++ return png_image_error(image,
++ "png_image_write_to_stdio: invalid argument");
++ }
++
++ else if (image != NULL)
++ return png_image_error(image,
++ "png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION");
++
++ else
++ return 0;
++}
++
++int PNGAPI
++png_image_write_to_file(png_imagep image, const char *file_name,
++ int convert_to_8bit, const void *buffer, png_int_32 row_stride,
++ const void *colormap)
++{
++ /* Write the image to the named file. */
++ if (image != NULL && image->version == PNG_IMAGE_VERSION)
++ {
++ if (file_name != NULL)
++ {
++ FILE *fp = fopen(file_name, "wb");
++
++ if (fp != NULL)
++ {
++ if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
++ row_stride, colormap) != 0)
++ {
++ int error; /* from fflush/fclose */
++
++ /* Make sure the file is flushed correctly. */
++ if (fflush(fp) == 0 && ferror(fp) == 0)
++ {
++ if (fclose(fp) == 0)
++ return 1;
++
++ error = errno; /* from fclose */
++ }
++
++ else
++ {
++ error = errno; /* from fflush or ferror */
++ (void)fclose(fp);
++ }
++
++ (void)remove(file_name);
++ /* The image has already been cleaned up; this is just used to
++ * set the error (because the original write succeeded).
++ */
++ return png_image_error(image, strerror(error));
++ }
++
++ else
++ {
++ /* Clean up: just the opened file. */
++ (void)fclose(fp);
++ (void)remove(file_name);
++ return 0;
++ }
++ }
++
++ else
++ return png_image_error(image, strerror(errno));
++ }
++
++ else
++ return png_image_error(image,
++ "png_image_write_to_file: invalid argument");
++ }
++
++ else if (image != NULL)
++ return png_image_error(image,
++ "png_image_write_to_file: incorrect PNG_IMAGE_VERSION");
++
++ else
++ return 0;
++}
++#endif /* STDIO */
++#endif /* SIMPLIFIED_WRITE */
++#endif /* WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pngwtran.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngwtran.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -42,90 +42,14 @@
+ #include "pngpriv.h"
+
+ #ifdef PNG_WRITE_SUPPORTED
+-
+ #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+-/* Transform the data according to the user's wishes. The order of
+- * transformations is significant.
+- */
+-void /* PRIVATE */
+-png_do_write_transformations(png_structp png_ptr)
+-{
+- png_debug(1, "in png_do_write_transformations");
+-
+- if (png_ptr == NULL)
+- return;
+-
+-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+- if (png_ptr->transformations & PNG_USER_TRANSFORM)
+- if (png_ptr->write_user_transform_fn != NULL)
+- (*(png_ptr->write_user_transform_fn)) /* User write transform
+- function */
+- (png_ptr, /* png_ptr */
+- &(png_ptr->row_info), /* row_info: */
+- /* png_uint_32 width; width of row */
+- /* png_size_t rowbytes; number of bytes in row */
+- /* png_byte color_type; color type of pixels */
+- /* png_byte bit_depth; bit depth of samples */
+- /* png_byte channels; number of channels (1-4) */
+- /* png_byte pixel_depth; bits per pixel (depth*channels) */
+- png_ptr->row_buf + 1); /* start of pixel data for row */
+-#endif
+-
+-#ifdef PNG_WRITE_FILLER_SUPPORTED
+- if (png_ptr->transformations & PNG_FILLER)
+- png_do_strip_channel(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
+-#endif
+-
+-#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
+- if (png_ptr->transformations & PNG_PACKSWAP)
+- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_WRITE_PACK_SUPPORTED
+- if (png_ptr->transformations & PNG_PACK)
+- png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- (png_uint_32)png_ptr->bit_depth);
+-#endif
+-
+-#ifdef PNG_WRITE_SWAP_SUPPORTED
+- if (png_ptr->transformations & PNG_SWAP_BYTES)
+- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_WRITE_SHIFT_SUPPORTED
+- if (png_ptr->transformations & PNG_SHIFT)
+- png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
+- &(png_ptr->shift));
+-#endif
+-
+-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+- if (png_ptr->transformations & PNG_SWAP_ALPHA)
+- png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+- if (png_ptr->transformations & PNG_INVERT_ALPHA)
+- png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_WRITE_BGR_SUPPORTED
+- if (png_ptr->transformations & PNG_BGR)
+- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-
+-#ifdef PNG_WRITE_INVERT_SUPPORTED
+- if (png_ptr->transformations & PNG_INVERT_MONO)
+- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
+-#endif
+-}
+
+ #ifdef PNG_WRITE_PACK_SUPPORTED
+ /* Pack pixels into bytes. Pass the true bit depth in bit_depth. The
+ * row_info bit depth should be 8 (one pixel per byte). The channels
+ * should be 1 (this only happens on grayscale and paletted images).
+ */
+-void /* PRIVATE */
++static void
+ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
+ {
+ png_debug(1, "in png_do_pack");
+@@ -270,7 +194,7 @@
+ * would pass 3 as bit_depth, and this routine would translate the
+ * data to 0 to 15.
+ */
+-void /* PRIVATE */
++static void
+ png_do_shift(png_row_infop row_info, png_bytep row,
+ png_const_color_8p bit_depth)
+ {
+@@ -281,7 +205,7 @@
+ int shift_start[4], shift_dec[4];
+ int channels = 0;
+
+- if (row_info->color_type & PNG_COLOR_MASK_COLOR)
++ if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+ shift_start[channels] = row_info->bit_depth - bit_depth->red;
+ shift_dec[channels] = bit_depth->red;
+@@ -303,7 +227,7 @@
+ channels++;
+ }
+
+- if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
++ if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
+ {
+ shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
+ shift_dec[channels] = bit_depth->alpha;
+@@ -315,7 +239,7 @@
+ {
+ png_bytep bp = row;
+ png_size_t i;
+- png_byte mask;
++ unsigned int mask;
+ png_size_t row_bytes = row_info->rowbytes;
+
+ if (bit_depth->gray == 1 && row_info->bit_depth == 2)
+@@ -329,20 +253,22 @@
+
+ for (i = 0; i < row_bytes; i++, bp++)
+ {
+- png_uint_16 v;
+ int j;
++ unsigned int v, out;
+
+ v = *bp;
+- *bp = 0;
++ out = 0;
+
+ for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
+ {
+ if (j > 0)
+- *bp |= (png_byte)((v << j) & 0xff);
++ out |= v << j;
+
+ else
+- *bp |= (png_byte)((v >> (-j)) & mask);
++ out |= (v >> (-j)) & mask;
+ }
++
++ *bp = (png_byte)(out & 0xff);
+ }
+ }
+
+@@ -355,21 +281,23 @@
+ for (i = 0; i < istop; i++, bp++)
+ {
+
+- png_uint_16 v;
++ const unsigned int c = i%channels;
+ int j;
+- int c = (int)(i%channels);
++ unsigned int v, out;
+
+ v = *bp;
+- *bp = 0;
++ out = 0;
+
+ for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+ {
+ if (j > 0)
+- *bp |= (png_byte)((v << j) & 0xff);
++ out |= v << j;
+
+ else
+- *bp |= (png_byte)((v >> (-j)) & 0xff);
++ out |= v >> (-j);
+ }
++
++ *bp = (png_byte)(out & 0xff);
+ }
+ }
+
+@@ -381,22 +309,22 @@
+
+ for (bp = row, i = 0; i < istop; i++)
+ {
+- int c = (int)(i%channels);
+- png_uint_16 value, v;
++ const unsigned int c = i%channels;
+ int j;
++ unsigned int value, v;
+
+- v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));
++ v = png_get_uint_16(bp);
+ value = 0;
+
+ for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
+ {
+ if (j > 0)
+- value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
++ value |= v << j;
+
+ else
+- value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
++ value |= v >> (-j);
+ }
+- *bp++ = (png_byte)(value >> 8);
++ *bp++ = (png_byte)((value >> 8) & 0xff);
+ *bp++ = (png_byte)(value & 0xff);
+ }
+ }
+@@ -405,7 +333,7 @@
+ #endif
+
+ #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+-void /* PRIVATE */
++static void
+ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
+ {
+ png_debug(1, "in png_do_write_swap_alpha");
+@@ -453,7 +381,7 @@
+ *(dp++) = save[1];
+ }
+ }
+-#endif /* PNG_WRITE_16BIT_SUPPORTED */
++#endif /* WRITE_16BIT */
+ }
+
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+@@ -492,14 +420,14 @@
+ *(dp++) = save[1];
+ }
+ }
+-#endif /* PNG_WRITE_16BIT_SUPPORTED */
++#endif /* WRITE_16BIT */
+ }
+ }
+ }
+ #endif
+
+ #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+-void /* PRIVATE */
++static void
+ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
+ {
+ png_debug(1, "in png_do_write_invert_alpha");
+@@ -549,7 +477,7 @@
+ *(dp++) = (png_byte)(255 - *(sp++));
+ }
+ }
+-#endif /* PNG_WRITE_16BIT_SUPPORTED */
++#endif /* WRITE_16BIT */
+ }
+
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+@@ -587,75 +515,88 @@
+ *(dp++) = (png_byte)(255 - *(sp++));
+ }
+ }
+-#endif /* PNG_WRITE_16BIT_SUPPORTED */
++#endif /* WRITE_16BIT */
+ }
+ }
+ }
+ #endif
+-#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */
+
+-#ifdef PNG_MNG_FEATURES_SUPPORTED
+-/* Undoes intrapixel differencing */
++/* Transform the data according to the user's wishes. The order of
++ * transformations is significant.
++ */
+ void /* PRIVATE */
+-png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
++png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
+ {
+- png_debug(1, "in png_do_write_intrapixel");
++ png_debug(1, "in png_do_write_transformations");
+
+- if ((row_info->color_type & PNG_COLOR_MASK_COLOR))
+- {
+- int bytes_per_pixel;
+- png_uint_32 row_width = row_info->width;
+- if (row_info->bit_depth == 8)
+- {
+- png_bytep rp;
+- png_uint_32 i;
++ if (png_ptr == NULL)
++ return;
+
+- if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+- bytes_per_pixel = 3;
++#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
++ if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
++ if (png_ptr->write_user_transform_fn != NULL)
++ (*(png_ptr->write_user_transform_fn)) /* User write transform
++ function */
++ (png_ptr, /* png_ptr */
++ row_info, /* row_info: */
++ /* png_uint_32 width; width of row */
++ /* png_size_t rowbytes; number of bytes in row */
++ /* png_byte color_type; color type of pixels */
++ /* png_byte bit_depth; bit depth of samples */
++ /* png_byte channels; number of channels (1-4) */
++ /* png_byte pixel_depth; bits per pixel (depth*channels) */
++ png_ptr->row_buf + 1); /* start of pixel data for row */
++#endif
+
+- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+- bytes_per_pixel = 4;
++#ifdef PNG_WRITE_FILLER_SUPPORTED
++ if ((png_ptr->transformations & PNG_FILLER) != 0)
++ png_do_strip_channel(row_info, png_ptr->row_buf + 1,
++ !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
++#endif
+
+- else
+- return;
++#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
++ png_do_packswap(row_info, png_ptr->row_buf + 1);
++#endif
+
+- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+- {
+- *(rp) = (png_byte)((*rp - *(rp + 1)) & 0xff);
+- *(rp + 2) = (png_byte)((*(rp + 2) - *(rp + 1)) & 0xff);
+- }
+- }
++#ifdef PNG_WRITE_PACK_SUPPORTED
++ if ((png_ptr->transformations & PNG_PACK) != 0)
++ png_do_pack(row_info, png_ptr->row_buf + 1,
++ (png_uint_32)png_ptr->bit_depth);
++#endif
+
+-#ifdef PNG_WRITE_16BIT_SUPPORTED
+- else if (row_info->bit_depth == 16)
+- {
+- png_bytep rp;
+- png_uint_32 i;
++#ifdef PNG_WRITE_SWAP_SUPPORTED
++# ifdef PNG_16BIT_SUPPORTED
++ if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
++ png_do_swap(row_info, png_ptr->row_buf + 1);
++# endif
++#endif
+
+- if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+- bytes_per_pixel = 6;
++#ifdef PNG_WRITE_SHIFT_SUPPORTED
++ if ((png_ptr->transformations & PNG_SHIFT) != 0)
++ png_do_shift(row_info, png_ptr->row_buf + 1,
++ &(png_ptr->shift));
++#endif
+
+- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+- bytes_per_pixel = 8;
++#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
++ if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
++ png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
++#endif
+
+- else
+- return;
++#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
++ if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
++ png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
++#endif
+
+- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
+- {
+- png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1);
+- png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);
+- png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);
+- png_uint_32 red = (png_uint_32)((s0 - s1) & 0xffffL);
+- png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
+- *(rp ) = (png_byte)((red >> 8) & 0xff);
+- *(rp + 1) = (png_byte)(red & 0xff);
+- *(rp + 4) = (png_byte)((blue >> 8) & 0xff);
+- *(rp + 5) = (png_byte)(blue & 0xff);
+- }
+- }
+-#endif /* PNG_WRITE_16BIT_SUPPORTED */
+- }
++#ifdef PNG_WRITE_BGR_SUPPORTED
++ if ((png_ptr->transformations & PNG_BGR) != 0)
++ png_do_bgr(row_info, png_ptr->row_buf + 1);
++#endif
++
++#ifdef PNG_WRITE_INVERT_SUPPORTED
++ if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
++ png_do_invert(row_info, png_ptr->row_buf + 1);
++#endif
+ }
+-#endif /* PNG_MNG_FEATURES_SUPPORTED */
+-#endif /* PNG_WRITE_SUPPORTED */
++#endif /* WRITE_TRANSFORMS */
++#endif /* WRITE */
+--- ./jdk/src/share/native/sun/awt/libpng/pngwutil.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/awt/libpng/pngwutil.c Thu Feb 05 13:00:26 2015 +0100
+@@ -29,8 +29,8 @@
+ * However, the following notice accompanied the original version of this
+ * file and, per its terms, should not be removed:
+ *
+- * Last changed in libpng 1.5.4 [July 7, 2011]
+- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
++ * Last changed in libpng 1.6.15 [November 20, 2014]
++ * Copyright (c) 1998-2014 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.)
+ *
+@@ -57,23 +57,6 @@
+ 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.
+@@ -93,7 +76,7 @@
+ * bytes have already been written.
+ */
+ void PNGAPI
+-png_write_sig(png_structp png_ptr)
++png_write_sig(png_structrp png_ptr)
+ {
+ png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+
+@@ -110,6 +93,104 @@
+ png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
+ }
+
++/* Write the start of a PNG chunk. The type is the chunk type.
++ * The total_length is the sum of the lengths of all the data you will be
++ * passing in png_write_chunk_data().
++ */
++static void
++png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name,
++ png_uint_32 length)
++{
++ png_byte buf[8];
++
++#if defined(PNG_DEBUG) && (PNG_DEBUG > 0)
++ PNG_CSTRING_FROM_CHUNK(buf, chunk_name);
++ png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length);
++#endif
++
++ if (png_ptr == NULL)
++ return;
++
++#ifdef PNG_IO_STATE_SUPPORTED
++ /* Inform the I/O callback that the chunk header is being written.
++ * PNG_IO_CHUNK_HDR requires a single I/O call.
++ */
++ png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
++#endif
++
++ /* Write the length and the chunk name */
++ png_save_uint_32(buf, length);
++ png_save_uint_32(buf + 4, chunk_name);
++ png_write_data(png_ptr, buf, 8);
++
++ /* Put the chunk name into png_ptr->chunk_name */
++ png_ptr->chunk_name = chunk_name;
++
++ /* Reset the crc and run it over the chunk name */
++ png_reset_crc(png_ptr);
++
++ png_calculate_crc(png_ptr, buf + 4, 4);
++
++#ifdef PNG_IO_STATE_SUPPORTED
++ /* Inform the I/O callback that chunk data will (possibly) be written.
++ * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.
++ */
++ png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;
++#endif
++}
++
++void PNGAPI
++png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string,
++ png_uint_32 length)
++{
++ png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length);
++}
++
++/* Write the data of a PNG chunk started with png_write_chunk_header().
++ * Note that multiple calls to this function are allowed, and that the
++ * sum of the lengths from these calls *must* add up to the total_length
++ * given to png_write_chunk_header().
++ */
++void PNGAPI
++png_write_chunk_data(png_structrp png_ptr, png_const_bytep data,
++ png_size_t length)
++{
++ /* Write the data, and run the CRC over it */
++ if (png_ptr == NULL)
++ return;
++
++ if (data != NULL && length > 0)
++ {
++ png_write_data(png_ptr, data, length);
++
++ /* Update the CRC after writing the data,
++ * in case the user I/O routine alters it.
++ */
++ png_calculate_crc(png_ptr, data, length);
++ }
++}
++
++/* Finish a chunk started with png_write_chunk_header(). */
++void PNGAPI
++png_write_chunk_end(png_structrp png_ptr)
++{
++ png_byte buf[4];
++
++ if (png_ptr == NULL) return;
++
++#ifdef PNG_IO_STATE_SUPPORTED
++ /* Inform the I/O callback that the chunk CRC is being written.
++ * PNG_IO_CHUNK_CRC requires a single I/O function call.
++ */
++ png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
++#endif
++
++ /* Write the crc in a single operation */
++ png_save_uint_32(buf, png_ptr->crc);
++
++ png_write_data(png_ptr, buf, (png_size_t)4);
++}
++
+ /* Write a PNG chunk all at once. The type is an array of ASCII characters
+ * representing the chunk name. The array must be at least 4 bytes in
+ * length, and does not need to be null terminated. To be safe, pass the
+@@ -119,569 +200,592 @@
+ * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
+ * functions instead.
+ */
+-void PNGAPI
+-png_write_chunk(png_structp png_ptr, png_const_bytep chunk_name,
++static void
++png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
+ png_const_bytep data, png_size_t length)
+ {
+ if (png_ptr == NULL)
+ return;
+
+- png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);
+- png_write_chunk_data(png_ptr, data, (png_size_t)length);
++ /* On 64 bit architectures 'length' may not fit in a png_uint_32. */
++ if (length > PNG_UINT_31_MAX)
++ png_error(png_ptr, "length exceeds PNG maximum");
++
++ png_write_chunk_header(png_ptr, chunk_name, (png_uint_32)length);
++ png_write_chunk_data(png_ptr, data, length);
+ png_write_chunk_end(png_ptr);
+ }
+
+-/* Write the start of a PNG chunk. The type is the chunk type.
+- * The total_length is the sum of the lengths of all the data you will be
+- * passing in png_write_chunk_data().
++/* This is the API that calls the internal function above. */
++void PNGAPI
++png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
++ png_const_bytep data, png_size_t length)
++{
++ png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
++ length);
++}
++
++/* This is used below to find the size of an image to pass to png_deflate_claim,
++ * so it only needs to be accurate if the size is less than 16384 bytes (the
++ * point at which a lower LZ window size can be used.)
+ */
+-void PNGAPI
+-png_write_chunk_start(png_structp png_ptr, png_const_bytep chunk_name,
+- png_uint_32 length)
++static png_alloc_size_t
++png_image_size(png_structrp png_ptr)
+ {
+- png_byte buf[8];
+-
+- png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,
+- (unsigned long)length);
+-
+- if (png_ptr == NULL)
+- return;
+-
+-#ifdef PNG_IO_STATE_SUPPORTED
+- /* Inform the I/O callback that the chunk header is being written.
+- * PNG_IO_CHUNK_HDR requires a single I/O call.
++ /* Only return sizes up to the maximum of a png_uint_32; do this by limiting
++ * the width and height used to 15 bits.
+ */
+- png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
+-#endif
+-
+- /* Write the length and the chunk name */
+- png_save_uint_32(buf, length);
+- png_memcpy(buf + 4, chunk_name, 4);
+- png_write_data(png_ptr, buf, (png_size_t)8);
+-
+- /* Put the chunk name into png_ptr->chunk_name */
+- png_memcpy(png_ptr->chunk_name, chunk_name, 4);
+-
+- /* Reset the crc and run it over the chunk name */
+- png_reset_crc(png_ptr);
+-
+- png_calculate_crc(png_ptr, chunk_name, 4);
+-
+-#ifdef PNG_IO_STATE_SUPPORTED
+- /* Inform the I/O callback that chunk data will (possibly) be written.
+- * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.
++ png_uint_32 h = png_ptr->height;
++
++ if (png_ptr->rowbytes < 32768 && h < 32768)
++ {
++ if (png_ptr->interlaced != 0)
++ {
++ /* Interlacing makes the image larger because of the replication of
++ * both the filter byte and the padding to a byte boundary.
++ */
++ png_uint_32 w = png_ptr->width;
++ unsigned int pd = png_ptr->pixel_depth;
++ png_alloc_size_t cb_base;
++ int pass;
++
++ for (cb_base=0, pass=0; pass<=6; ++pass)
++ {
++ png_uint_32 pw = PNG_PASS_COLS(w, pass);
++
++ if (pw > 0)
++ cb_base += (PNG_ROWBYTES(pd, pw)+1) * PNG_PASS_ROWS(h, pass);
++ }
++
++ return cb_base;
++ }
++
++ else
++ return (png_ptr->rowbytes+1) * h;
++ }
++
++ else
++ return 0xffffffffU;
++}
++
++#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
++ /* This is the code to hack the first two bytes of the deflate stream (the
++ * deflate header) to correct the windowBits value to match the actual data
++ * size. Note that the second argument is the *uncompressed* size but the
++ * first argument is the *compressed* data (and it must be deflate
++ * compressed.)
+ */
+- png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;
+-#endif
+-}
+-
+-/* Write the data of a PNG chunk started with png_write_chunk_start().
+- * Note that multiple calls to this function are allowed, and that the
+- * sum of the lengths from these calls *must* add up to the total_length
+- * given to png_write_chunk_start().
+- */
+-void PNGAPI
+-png_write_chunk_data(png_structp png_ptr, png_const_bytep data,
+- png_size_t length)
++static void
++optimize_cmf(png_bytep data, png_alloc_size_t data_size)
+ {
+- /* Write the data, and run the CRC over it */
+- if (png_ptr == NULL)
+- return;
+-
+- if (data != NULL && length > 0)
++ /* Optimize the CMF field in the zlib stream. The resultant zlib stream is
++ * still compliant to the stream specification.
++ */
++ if (data_size <= 16384) /* else windowBits must be 15 */
+ {
+- png_write_data(png_ptr, data, length);
+-
+- /* Update the CRC after writing the data,
+- * in case that the user I/O routine alters it.
+- */
+- png_calculate_crc(png_ptr, data, length);
++ unsigned int z_cmf = data[0]; /* zlib compression method and flags */
++
++ if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
++ {
++ unsigned int z_cinfo;
++ unsigned int half_z_window_size;
++
++ z_cinfo = z_cmf >> 4;
++ half_z_window_size = 1U << (z_cinfo + 7);
++
++ if (data_size <= half_z_window_size) /* else no change */
++ {
++ unsigned int tmp;
++
++ do
++ {
++ half_z_window_size >>= 1;
++ --z_cinfo;
++ }
++ while (z_cinfo > 0 && data_size <= half_z_window_size);
++
++ z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
++
++ data[0] = (png_byte)z_cmf;
++ tmp = data[1] & 0xe0;
++ tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
++ data[1] = (png_byte)tmp;
++ }
++ }
+ }
+ }
+-
+-/* Finish a chunk started with png_write_chunk_start(). */
+-void PNGAPI
+-png_write_chunk_end(png_structp png_ptr)
++#endif /* WRITE_OPTIMIZE_CMF */
++
++/* Initialize the compressor for the appropriate type of compression. */
++static int
++png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
++ png_alloc_size_t data_size)
+ {
+- png_byte buf[4];
+-
+- if (png_ptr == NULL) return;
+-
+-#ifdef PNG_IO_STATE_SUPPORTED
+- /* Inform the I/O callback that the chunk CRC is being written.
+- * PNG_IO_CHUNK_CRC requires a single I/O function call.
+- */
+- png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
++ if (png_ptr->zowner != 0)
++ {
++#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
++ char msg[64];
++
++ PNG_STRING_FROM_CHUNK(msg, owner);
++ msg[4] = ':';
++ msg[5] = ' ';
++ PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner);
++ /* So the message that results is "<chunk> using zstream"; this is an
++ * internal error, but is very useful for debugging. i18n requirements
++ * are minimal.
++ */
++ (void)png_safecat(msg, (sizeof msg), 10, " using zstream");
+ #endif
+-
+- /* Write the crc in a single operation */
+- png_save_uint_32(buf, png_ptr->crc);
+-
+- png_write_data(png_ptr, buf, (png_size_t)4);
+-}
+-
+-/* Initialize the compressor for the appropriate type of compression. */
+-static void
+-png_zlib_claim(png_structp png_ptr, png_uint_32 state)
+-{
+- if (!(png_ptr->zlib_state & PNG_ZLIB_IN_USE))
++#if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
++ png_warning(png_ptr, msg);
++
++ /* Attempt sane error recovery */
++ if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */
++ {
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT");
++ return Z_STREAM_ERROR;
++ }
++
++ png_ptr->zowner = 0;
++#else
++ png_error(png_ptr, msg);
++#endif
++ }
++
+ {
+- /* If already initialized for 'state' do not re-init. */
+- if (png_ptr->zlib_state != state)
++ int level = png_ptr->zlib_level;
++ int method = png_ptr->zlib_method;
++ int windowBits = png_ptr->zlib_window_bits;
++ int memLevel = png_ptr->zlib_mem_level;
++ int strategy; /* set below */
++ int ret; /* zlib return code */
++
++ if (owner == png_IDAT)
+ {
+- int ret = Z_OK;
+- png_const_charp who = "-";
+-
+- /* If actually initialized for another state do a deflateEnd. */
+- if (png_ptr->zlib_state != PNG_ZLIB_UNINITIALIZED)
++ if ((png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) != 0)
++ strategy = png_ptr->zlib_strategy;
++
++ else if (png_ptr->do_filter != PNG_FILTER_NONE)
++ strategy = PNG_Z_DEFAULT_STRATEGY;
++
++ else
++ strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;
++ }
++
++ else
++ {
++#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
++ level = png_ptr->zlib_text_level;
++ method = png_ptr->zlib_text_method;
++ windowBits = png_ptr->zlib_text_window_bits;
++ memLevel = png_ptr->zlib_text_mem_level;
++ strategy = png_ptr->zlib_text_strategy;
++#else
++ /* If customization is not supported the values all come from the
++ * IDAT values except for the strategy, which is fixed to the
++ * default. (This is the pre-1.6.0 behavior too, although it was
++ * implemented in a very different way.)
++ */
++ strategy = Z_DEFAULT_STRATEGY;
++#endif
++ }
++
++ /* Adjust 'windowBits' down if larger than 'data_size'; to stop this
++ * happening just pass 32768 as the data_size parameter. Notice that zlib
++ * requires an extra 262 bytes in the window in addition to the data to be
++ * able to see the whole of the data, so if data_size+262 takes us to the
++ * next windowBits size we need to fix up the value later. (Because even
++ * though deflate needs the extra window, inflate does not!)
++ */
++ if (data_size <= 16384)
++ {
++ /* IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to
++ * work round a Microsoft Visual C misbehavior which, contrary to C-90,
++ * widens the result of the following shift to 64-bits if (and,
++ * apparently, only if) it is used in a test.
++ */
++ unsigned int half_window_size = 1U << (windowBits-1);
++
++ while (data_size + 262 <= half_window_size)
+ {
+- ret = deflateEnd(&png_ptr->zstream);
+- who = "end";
+- png_ptr->zlib_state = PNG_ZLIB_UNINITIALIZED;
+- }
+-
+- /* zlib itself detects an incomplete state on deflateEnd */
+- if (ret == Z_OK) switch (state)
+- {
+-# ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
+- case PNG_ZLIB_FOR_TEXT:
+- ret = deflateInit2(&png_ptr->zstream,
+- png_ptr->zlib_text_level, png_ptr->zlib_text_method,
+- png_ptr->zlib_text_window_bits,
+- png_ptr->zlib_text_mem_level, png_ptr->zlib_text_strategy);
+- who = "text";
+- break;
+-# endif
+-
+- case PNG_ZLIB_FOR_IDAT:
+- ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,
+- png_ptr->zlib_method, png_ptr->zlib_window_bits,
+- png_ptr->zlib_mem_level, png_ptr->zlib_strategy);
+- who = "IDAT";
+- break;
+-
+- default:
+- png_error(png_ptr, "invalid zlib state");
+- }
+-
+- if (ret == Z_OK)
+- png_ptr->zlib_state = state;
+-
+- else /* an error in deflateEnd or deflateInit2 */
+- {
+- size_t pos = 0;
+- char msg[64];
+-
+- pos = png_safecat(msg, sizeof msg, pos,
+- "zlib failed to initialize compressor (");
+- pos = png_safecat(msg, sizeof msg, pos, who);
+-
+- switch (ret)
+- {
+- case Z_VERSION_ERROR:
+- pos = png_safecat(msg, sizeof msg, pos, ") version error");
+- break;
+-
+- case Z_STREAM_ERROR:
+- pos = png_safecat(msg, sizeof msg, pos, ") stream error");
+- break;
+-
+- case Z_MEM_ERROR:
+- pos = png_safecat(msg, sizeof msg, pos, ") memory error");
+- break;
+-
+- default:
+- pos = png_safecat(msg, sizeof msg, pos, ") unknown error");
+- break;
+- }
+-
+- png_error(png_ptr, msg);
++ half_window_size >>= 1;
++ --windowBits;
+ }
+ }
+
+- /* Here on success, claim the zstream: */
+- png_ptr->zlib_state |= PNG_ZLIB_IN_USE;
++ /* Check against the previous initialized values, if any. */
++ if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0 &&
++ (png_ptr->zlib_set_level != level ||
++ png_ptr->zlib_set_method != method ||
++ png_ptr->zlib_set_window_bits != windowBits ||
++ png_ptr->zlib_set_mem_level != memLevel ||
++ png_ptr->zlib_set_strategy != strategy))
++ {
++ if (deflateEnd(&png_ptr->zstream) != Z_OK)
++ png_warning(png_ptr, "deflateEnd failed (ignored)");
++
++ png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED;
++ }
++
++ /* For safety clear out the input and output pointers (currently zlib
++ * doesn't use them on Init, but it might in the future).
++ */
++ png_ptr->zstream.next_in = NULL;
++ png_ptr->zstream.avail_in = 0;
++ png_ptr->zstream.next_out = NULL;
++ png_ptr->zstream.avail_out = 0;
++
++ /* Now initialize if required, setting the new parameters, otherwise just
++ * to a simple reset to the previous parameters.
++ */
++ if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
++ ret = deflateReset(&png_ptr->zstream);
++
++ else
++ {
++ ret = deflateInit2(&png_ptr->zstream, level, method, windowBits,
++ memLevel, strategy);
++
++ if (ret == Z_OK)
++ png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
++ }
++
++ /* The return code is from either deflateReset or deflateInit2; they have
++ * pretty much the same set of error codes.
++ */
++ if (ret == Z_OK)
++ png_ptr->zowner = owner;
++
++ else
++ png_zstream_error(png_ptr, ret);
++
++ return ret;
+ }
+-
+- else
+- png_error(png_ptr, "zstream already in use (internal error)");
+ }
+
+-/* The opposite: release the stream. It is also reset, this API will warn on
+- * error but will not fail.
+- */
+-static void
+-png_zlib_release(png_structp png_ptr)
++/* Clean up (or trim) a linked list of compression buffers. */
++void /* PRIVATE */
++png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp)
+ {
+- if (png_ptr->zlib_state & PNG_ZLIB_IN_USE)
++ png_compression_bufferp list = *listp;
++
++ if (list != NULL)
+ {
+- int ret = deflateReset(&png_ptr->zstream);
+-
+- png_ptr->zlib_state &= ~PNG_ZLIB_IN_USE;
+-
+- if (ret != Z_OK)
++ *listp = NULL;
++
++ do
+ {
+- png_const_charp err;
+- PNG_WARNING_PARAMETERS(p)
+-
+- switch (ret)
+- {
+- case Z_VERSION_ERROR:
+- err = "version";
+- break;
+-
+- case Z_STREAM_ERROR:
+- err = "stream";
+- break;
+-
+- case Z_MEM_ERROR:
+- err = "memory";
+- break;
+-
+- default:
+- err = "unknown";
+- break;
+- }
+-
+- png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d, ret);
+- png_warning_parameter(p, 2, err);
+-
+- if (png_ptr->zstream.msg)
+- err = png_ptr->zstream.msg;
+- else
+- err = "[no zlib message]";
+-
+- png_warning_parameter(p, 3, err);
+-
+- png_formatted_warning(png_ptr, p,
+- "zlib failed to reset compressor: @1(@2): @3");
++ png_compression_bufferp next = list->next;
++
++ png_free(png_ptr, list);
++ list = next;
+ }
++ while (list != NULL);
+ }
+-
+- else
+- png_warning(png_ptr, "zstream not in use (internal error)");
+ }
+
+ #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
+ /* This pair of functions encapsulates the operation of (a) compressing a
+ * text string, and (b) issuing it later as a series of chunk data writes.
+ * The compression_state structure is shared context for these functions
+- * set up by the caller in order to make the whole mess thread-safe.
++ * set up by the caller to allow access to the relevant local variables.
++ *
++ * compression_buffer (new in 1.6.0) is just a linked list of zbuffer_size
++ * temporary buffers. From 1.6.0 it is retained in png_struct so that it will
++ * be correctly freed in the event of a write error (previous implementations
++ * just leaked memory.)
+ */
+-
+ typedef struct
+ {
+- png_const_bytep input; /* The uncompressed input data */
+- png_size_t input_len; /* Its length */
+- int num_output_ptr; /* Number of output pointers used */
+- int max_output_ptr; /* Size of output_ptr */
+- png_bytep *output_ptr; /* Array of pointers to output */
++ png_const_bytep input; /* The uncompressed input data */
++ png_alloc_size_t input_len; /* Its length */
++ png_uint_32 output_len; /* Final compressed length */
++ png_byte output[1024]; /* First block of output */
+ } compression_state;
+
+-/* Compress given text into storage in the png_ptr structure */
+-static int /* PRIVATE */
+-png_text_compress(png_structp png_ptr,
+- png_const_charp text, png_size_t text_len, int compression,
+- compression_state *comp)
++static void
++png_text_compress_init(compression_state *comp, png_const_bytep input,
++ png_alloc_size_t input_len)
++{
++ comp->input = input;
++ comp->input_len = input_len;
++ comp->output_len = 0;
++}
++
++/* Compress the data in the compression state input */
++static int
++png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
++ compression_state *comp, png_uint_32 prefix_len)
+ {
+ int ret;
+
+- comp->num_output_ptr = 0;
+- comp->max_output_ptr = 0;
+- comp->output_ptr = NULL;
+- comp->input = NULL;
+- comp->input_len = text_len;
+-
+- /* We may just want to pass the text right through */
+- if (compression == PNG_TEXT_COMPRESSION_NONE)
++ /* To find the length of the output it is necessary to first compress the
++ * input. The result is buffered rather than using the two-pass algorithm
++ * that is used on the inflate side; deflate is assumed to be slower and a
++ * PNG writer is assumed to have more memory available than a PNG reader.
++ *
++ * IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an
++ * upper limit on the output size, but it is always bigger than the input
++ * size so it is likely to be more efficient to use this linked-list
++ * approach.
++ */
++ ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len);
++
++ if (ret != Z_OK)
++ return ret;
++
++ /* Set up the compression buffers, we need a loop here to avoid overflowing a
++ * uInt. Use ZLIB_IO_MAX to limit the input. The output is always limited
++ * by the output buffer size, so there is no need to check that. Since this
++ * is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits
++ * in size.
++ */
+ {
+- comp->input = (png_const_bytep)text;
+- return((int)text_len);
++ png_compression_bufferp *end = &png_ptr->zbuffer_list;
++ png_alloc_size_t input_len = comp->input_len; /* may be zero! */
++ png_uint_32 output_len;
++
++ /* zlib updates these for us: */
++ png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input);
++ png_ptr->zstream.avail_in = 0; /* Set below */
++ png_ptr->zstream.next_out = comp->output;
++ png_ptr->zstream.avail_out = (sizeof comp->output);
++
++ output_len = png_ptr->zstream.avail_out;
++
++ do
++ {
++ uInt avail_in = ZLIB_IO_MAX;
++
++ if (avail_in > input_len)
++ avail_in = (uInt)input_len;
++
++ input_len -= avail_in;
++
++ png_ptr->zstream.avail_in = avail_in;
++
++ if (png_ptr->zstream.avail_out == 0)
++ {
++ png_compression_buffer *next;
++
++ /* Chunk data is limited to 2^31 bytes in length, so the prefix
++ * length must be counted here.
++ */
++ if (output_len + prefix_len > PNG_UINT_31_MAX)
++ {
++ ret = Z_MEM_ERROR;
++ break;
++ }
++
++ /* Need a new (malloc'ed) buffer, but there may be one present
++ * already.
++ */
++ next = *end;
++ if (next == NULL)
++ {
++ next = png_voidcast(png_compression_bufferp, png_malloc_base
++ (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
++
++ if (next == NULL)
++ {
++ ret = Z_MEM_ERROR;
++ break;
++ }
++
++ /* Link in this buffer (so that it will be freed later) */
++ next->next = NULL;
++ *end = next;
++ }
++
++ png_ptr->zstream.next_out = next->output;
++ png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
++ output_len += png_ptr->zstream.avail_out;
++
++ /* Move 'end' to the next buffer pointer. */
++ end = &next->next;
++ }
++
++ /* Compress the data */
++ ret = deflate(&png_ptr->zstream,
++ input_len > 0 ? Z_NO_FLUSH : Z_FINISH);
++
++ /* Claw back input data that was not consumed (because avail_in is
++ * reset above every time round the loop).
++ */
++ input_len += png_ptr->zstream.avail_in;
++ png_ptr->zstream.avail_in = 0; /* safety */
++ }
++ while (ret == Z_OK);
++
++ /* There may be some space left in the last output buffer. This needs to
++ * be subtracted from output_len.
++ */
++ output_len -= png_ptr->zstream.avail_out;
++ png_ptr->zstream.avail_out = 0; /* safety */
++ comp->output_len = output_len;
++
++ /* Now double check the output length, put in a custom message if it is
++ * too long. Otherwise ensure the z_stream::msg pointer is set to
++ * something.
++ */
++ if (output_len + prefix_len >= PNG_UINT_31_MAX)
++ {
++ png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long");
++ ret = Z_MEM_ERROR;
++ }
++
++ else
++ png_zstream_error(png_ptr, ret);
++
++ /* Reset zlib for another zTXt/iTXt or image data */
++ png_ptr->zowner = 0;
++
++ /* The only success case is Z_STREAM_END, input_len must be 0; if not this
++ * is an internal error.
++ */
++ if (ret == Z_STREAM_END && input_len == 0)
++ {
++#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
++ /* Fix up the deflate header, if required */
++ optimize_cmf(comp->output, comp->input_len);
++#endif
++ /* But Z_OK is returned, not Z_STREAM_END; this allows the claim
++ * function above to return Z_STREAM_END on an error (though it never
++ * does in the current versions of zlib.)
++ */
++ return Z_OK;
++ }
++
++ else
++ return ret;
+ }
+-
+- if (compression >= PNG_TEXT_COMPRESSION_LAST)
++}
++
++/* Ship the compressed text out via chunk writes */
++static void
++png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)
++{
++ png_uint_32 output_len = comp->output_len;
++ png_const_bytep output = comp->output;
++ png_uint_32 avail = (sizeof comp->output);
++ png_compression_buffer *next = png_ptr->zbuffer_list;
++
++ for (;;)
++ {
++ if (avail > output_len)
++ avail = output_len;
++
++ png_write_chunk_data(png_ptr, output, avail);
++
++ output_len -= avail;
++
++ if (output_len == 0 || next == NULL)
++ break;
++
++ avail = png_ptr->zbuffer_size;
++ output = next->output;
++ next = next->next;
++ }
++
++ /* This is an internal error; 'next' must have been NULL! */
++ if (output_len > 0)
++ png_error(png_ptr, "error writing ancillary chunked compressed data");
++}
++#endif /* WRITE_COMPRESSED_TEXT */
++
++#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
++ defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
++/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
++ * and if invalid, correct the keyword rather than discarding the entire
++ * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
++ * length, forbids leading or trailing whitespace, multiple internal spaces,
++ * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
++ *
++ * The 'new_key' buffer must be 80 characters in size (for the keyword plus a
++ * trailing '\0'). If this routine returns 0 then there was no keyword, or a
++ * valid one could not be generated, and the caller must png_error.
++ */
++static png_uint_32
++png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
++{
++ png_const_charp orig_key = key;
++ png_uint_32 key_len = 0;
++ int bad_character = 0;
++ int space = 1;
++
++ png_debug(1, "in png_check_keyword");
++
++ if (key == NULL)
++ {
++ *new_key = 0;
++ return 0;
++ }
++
++ while (*key && key_len < 79)
++ {
++ png_byte ch = (png_byte)(0xff & *key++);
++
++ if ((ch > 32 && ch <= 126) || (ch >= 161 /*&& ch <= 255*/))
++ *new_key++ = ch, ++key_len, space = 0;
++
++ else if (space == 0)
++ {
++ /* A space or an invalid character when one wasn't seen immediately
++ * before; output just a space.
++ */
++ *new_key++ = 32, ++key_len, space = 1;
++
++ /* If the character was not a space then it is invalid. */
++ if (ch != 32)
++ bad_character = ch;
++ }
++
++ else if (bad_character == 0)
++ bad_character = ch; /* just skip it, record the first error */
++ }
++
++ if (key_len > 0 && space != 0) /* trailing space */
++ {
++ --key_len, --new_key;
++ if (bad_character == 0)
++ bad_character = 32;
++ }
++
++ /* Terminate the keyword */
++ *new_key = 0;
++
++ if (key_len == 0)
++ return 0;
++
++#ifdef PNG_WARNINGS_SUPPORTED
++ /* Try to only output one warning per keyword: */
++ if (*key != 0) /* keyword too long */
++ png_warning(png_ptr, "keyword truncated");
++
++ else if (bad_character != 0)
+ {
+ PNG_WARNING_PARAMETERS(p)
+
+- png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d,
+- compression);
+- png_formatted_warning(png_ptr, p, "Unknown compression type @1");
++ png_warning_parameter(p, 1, orig_key);
++ png_warning_parameter_signed(p, 2, PNG_NUMBER_FORMAT_02x, bad_character);
++
++ png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'");
+ }
+-
+- /* We can't write the chunk until we find out how much data we have,
+- * which means we need to run the compressor first and save the
+- * output. This shouldn't be a problem, as the vast majority of
+- * comments should be reasonable, but we will set up an array of
+- * malloc'd pointers to be sure.
+- *
+- * If we knew the application was well behaved, we could simplify this
+- * greatly by assuming we can always malloc an output buffer large
+- * enough to hold the compressed text ((1001 * text_len / 1000) + 12)
+- * and malloc this directly. The only time this would be a bad idea is
+- * if we can't malloc more than 64K and we have 64K of random input
+- * data, or if the input string is incredibly large (although this
+- * wouldn't cause a failure, just a slowdown due to swapping).
+- */
+- png_zlib_claim(png_ptr, PNG_ZLIB_FOR_TEXT);
+-
+- /* Set up the compression buffers */
+- /* TODO: the following cast hides a potential overflow problem. */
+- png_ptr->zstream.avail_in = (uInt)text_len;
+-
+- /* NOTE: assume zlib doesn't overwrite the input */
+- png_ptr->zstream.next_in = (Bytef *)text;
+- png_ptr->zstream.avail_out = png_ptr->zbuf_size;
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+-
+- /* This is the same compression loop as in png_write_row() */
+- do
+- {
+- /* Compress the data */
+- ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
+-
+- if (ret != Z_OK)
+- {
+- /* Error */
+- if (png_ptr->zstream.msg != NULL)
+- png_error(png_ptr, png_ptr->zstream.msg);
+-
+- else
+- png_error(png_ptr, "zlib error");
+- }
+-
+- /* Check to see if we need more room */
+- if (!(png_ptr->zstream.avail_out))
+- {
+- /* Make sure the output array has room */
+- if (comp->num_output_ptr >= comp->max_output_ptr)
+- {
+- int old_max;
+-
+- old_max = comp->max_output_ptr;
+- comp->max_output_ptr = comp->num_output_ptr + 4;
+- if (comp->output_ptr != NULL)
+- {
+- png_bytepp old_ptr;
+-
+- old_ptr = comp->output_ptr;
+-
+- comp->output_ptr = (png_bytepp)png_malloc(png_ptr,
+- (png_alloc_size_t)
+- (comp->max_output_ptr * png_sizeof(png_charpp)));
+-
+- png_memcpy(comp->output_ptr, old_ptr, old_max
+- * png_sizeof(png_charp));
+-
+- png_free(png_ptr, old_ptr);
+- }
+- else
+- comp->output_ptr = (png_bytepp)png_malloc(png_ptr,
+- (png_alloc_size_t)
+- (comp->max_output_ptr * png_sizeof(png_charp)));
+- }
+-
+- /* Save the data */
+- comp->output_ptr[comp->num_output_ptr] =
+- (png_bytep)png_malloc(png_ptr,
+- (png_alloc_size_t)png_ptr->zbuf_size);
+-
+- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
+- png_ptr->zbuf_size);
+-
+- comp->num_output_ptr++;
+-
+- /* and reset the buffer */
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- }
+- /* Continue until we don't have any more to compress */
+- } while (png_ptr->zstream.avail_in);
+-
+- /* Finish the compression */
+- do
+- {
+- /* Tell zlib we are finished */
+- ret = deflate(&png_ptr->zstream, Z_FINISH);
+-
+- if (ret == Z_OK)
+- {
+- /* Check to see if we need more room */
+- if (!(png_ptr->zstream.avail_out))
+- {
+- /* Check to make sure our output array has room */
+- if (comp->num_output_ptr >= comp->max_output_ptr)
+- {
+- int old_max;
+-
+- old_max = comp->max_output_ptr;
+- comp->max_output_ptr = comp->num_output_ptr + 4;
+- if (comp->output_ptr != NULL)
+- {
+- png_bytepp old_ptr;
+-
+- old_ptr = comp->output_ptr;
+-
+- /* This could be optimized to realloc() */
+- comp->output_ptr = (png_bytepp)png_malloc(png_ptr,
+- (png_alloc_size_t)(comp->max_output_ptr *
+- png_sizeof(png_charp)));
+-
+- png_memcpy(comp->output_ptr, old_ptr,
+- old_max * png_sizeof(png_charp));
+-
+- png_free(png_ptr, old_ptr);
+- }
+-
+- else
+- comp->output_ptr = (png_bytepp)png_malloc(png_ptr,
+- (png_alloc_size_t)(comp->max_output_ptr *
+- png_sizeof(png_charp)));
+- }
+-
+- /* Save the data */
+- comp->output_ptr[comp->num_output_ptr] =
+- (png_bytep)png_malloc(png_ptr,
+- (png_alloc_size_t)png_ptr->zbuf_size);
+-
+- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
+- png_ptr->zbuf_size);
+-
+- comp->num_output_ptr++;
+-
+- /* and reset the buffer pointers */
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- }
+- }
+- else if (ret != Z_STREAM_END)
+- {
+- /* We got an error */
+- if (png_ptr->zstream.msg != NULL)
+- png_error(png_ptr, png_ptr->zstream.msg);
+-
+- else
+- png_error(png_ptr, "zlib error");
+- }
+- } while (ret != Z_STREAM_END);
+-
+- /* Text length is number of buffers plus last buffer */
+- text_len = png_ptr->zbuf_size * comp->num_output_ptr;
+-
+- if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
+- text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;
+-
+- return((int)text_len);
++#endif /* WARNINGS */
++
++ return key_len;
+ }
+-
+-/* Ship the compressed text out via chunk writes */
+-static void /* PRIVATE */
+-png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
+-{
+- int i;
+-
+- /* Handle the no-compression case */
+- if (comp->input)
+- {
+- png_write_chunk_data(png_ptr, comp->input, comp->input_len);
+-
+- return;
+- }
+-
+-#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
+- if (comp->input_len >= 2 && comp->input_len < 16384)
+- {
+- unsigned int z_cmf; /* zlib compression method and flags */
+-
+- /* Optimize the CMF field in the zlib stream. This hack of the zlib
+- * stream is compliant to the stream specification.
+- */
+-
+- if (comp->num_output_ptr)
+- z_cmf = comp->output_ptr[0][0];
+- else
+- z_cmf = png_ptr->zbuf[0];
+-
+- if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
+- {
+- unsigned int z_cinfo;
+- unsigned int half_z_window_size;
+- png_size_t uncompressed_text_size = comp->input_len;
+-
+- z_cinfo = z_cmf >> 4;
+- half_z_window_size = 1 << (z_cinfo + 7);
+-
+- while (uncompressed_text_size <= half_z_window_size &&
+- half_z_window_size >= 256)
+- {
+- z_cinfo--;
+- half_z_window_size >>= 1;
+- }
+-
+- z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
+-
+- if (comp->num_output_ptr)
+- {
+-
+- if (comp->output_ptr[0][0] != z_cmf)
+- {
+- int tmp;
+-
+- comp->output_ptr[0][0] = (png_byte)z_cmf;
+- tmp = comp->output_ptr[0][1] & 0xe0;
+- tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
+- comp->output_ptr[0][1] = (png_byte)tmp;
+- }
+- }
+- else
+- {
+- int tmp;
+-
+- png_ptr->zbuf[0] = (png_byte)z_cmf;
+- tmp = png_ptr->zbuf[1] & 0xe0;
+- tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
+- png_ptr->zbuf[1] = (png_byte)tmp;
+- }
+- }
+-
+- else
+- png_error(png_ptr,
+- "Invalid zlib compression method or flags in non-IDAT chunk");
+- }
+-#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */
+-
+- /* Write saved output buffers, if any */
+- for (i = 0; i < comp->num_output_ptr; i++)
+- {
+- png_write_chunk_data(png_ptr, comp->output_ptr[i],
+- (png_size_t)png_ptr->zbuf_size);
+-
+- png_free(png_ptr, comp->output_ptr[i]);
+- }
+-
+- if (comp->max_output_ptr != 0)
+- png_free(png_ptr, comp->output_ptr);
+-
+- /* Write anything left in zbuf */
+- if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
+- png_write_chunk_data(png_ptr, png_ptr->zbuf,
+- (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));
+-
+- /* Reset zlib for another zTXt/iTXt or image data */
+- png_zlib_release(png_ptr);
+-}
+-#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */
++#endif /* WRITE_TEXT || WRITE_pCAL || WRITE_iCCP || WRITE_sPLT */
+
+ /* Write the IHDR chunk, and update the png_struct with the necessary
+ * information. Note that the rest of this code depends upon this
+ * information being correct.
+ */
+ void /* PRIVATE */
+-png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
++png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
+ int bit_depth, int color_type, int compression_type, int filter_type,
+ int interlace_type)
+ {
+- PNG_IHDR;
+-
+ png_byte buf[13]; /* Buffer to store the IHDR info */
+
+ png_debug(1, "in png_write_IHDR");
+@@ -772,8 +876,8 @@
+ */
+ if (
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+- !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+- ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
++ !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
++ ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
+ (color_type == PNG_COLOR_TYPE_RGB ||
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
+ (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
+@@ -823,14 +927,9 @@
+ buf[12] = (png_byte)interlace_type;
+
+ /* Write the chunk */
+- png_write_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
+-
+- /* Initialize zlib with PNG info */
+- png_ptr->zstream.zalloc = png_zalloc;
+- png_ptr->zstream.zfree = png_zfree;
+- png_ptr->zstream.opaque = (voidpf)png_ptr;
+-
+- if (!(png_ptr->do_filter))
++ png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
++
++ if ((png_ptr->do_filter) == PNG_NO_FILTERS)
+ {
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
+ png_ptr->bit_depth < 8)
+@@ -840,55 +939,6 @@
+ png_ptr->do_filter = PNG_ALL_FILTERS;
+ }
+
+- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))
+- {
+- if (png_ptr->do_filter != PNG_FILTER_NONE)
+- png_ptr->zlib_strategy = Z_FILTERED;
+-
+- else
+- png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;
+- }
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))
+- png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))
+- png_ptr->zlib_mem_level = 8;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))
+- png_ptr->zlib_window_bits = 15;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))
+- png_ptr->zlib_method = 8;
+-
+-#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
+-#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+- if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_STRATEGY))
+- png_ptr->zlib_text_strategy = Z_DEFAULT_STRATEGY;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_LEVEL))
+- png_ptr->zlib_text_level = png_ptr->zlib_level;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_MEM_LEVEL))
+- png_ptr->zlib_text_mem_level = png_ptr->zlib_mem_level;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_WINDOW_BITS))
+- png_ptr->zlib_text_window_bits = png_ptr->zlib_window_bits;
+-
+- if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_METHOD))
+- png_ptr->zlib_text_method = png_ptr->zlib_method;
+-#else
+- png_ptr->zlib_text_strategy = Z_DEFAULT_STRATEGY;
+- png_ptr->zlib_text_level = png_ptr->zlib_level;
+- png_ptr->zlib_text_mem_level = png_ptr->zlib_mem_level;
+- png_ptr->zlib_text_window_bits = png_ptr->zlib_window_bits;
+- png_ptr->zlib_text_method = png_ptr->zlib_method;
+-#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */
+-#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */
+-
+- /* Record that the compressor has not yet been initialized. */
+- png_ptr->zlib_state = PNG_ZLIB_UNINITIALIZED;
+-
+ png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */
+ }
+
+@@ -897,10 +947,9 @@
+ * structure.
+ */
+ void /* PRIVATE */
+-png_write_PLTE(png_structp png_ptr, png_const_colorp palette,
++png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
+ png_uint_32 num_pal)
+ {
+- PNG_PLTE;
+ png_uint_32 i;
+ png_const_colorp pal_ptr;
+ png_byte buf[3];
+@@ -909,7 +958,7 @@
+
+ if ((
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+- !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
++ (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 &&
+ #endif
+ num_pal == 0) || num_pal > 256)
+ {
+@@ -925,7 +974,7 @@
+ }
+ }
+
+- if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
+ {
+ png_warning(png_ptr,
+ "Ignoring request to write a PLTE chunk in grayscale PNG");
+@@ -936,7 +985,7 @@
+ png_ptr->num_palette = (png_uint_16)num_pal;
+ png_debug1(3, "num_palette = %d", png_ptr->num_palette);
+
+- png_write_chunk_start(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
++ png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
+ #ifdef PNG_POINTER_INDEXING_SUPPORTED
+
+ for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
+@@ -966,127 +1015,192 @@
+ png_ptr->mode |= PNG_HAVE_PLTE;
+ }
+
+-/* Write an IDAT chunk */
++/* This is similar to png_text_compress, above, except that it does not require
++ * all of the data at once and, instead of buffering the compressed result,
++ * writes it as IDAT chunks. Unlike png_text_compress it *can* png_error out
++ * because it calls the write interface. As a result it does its own error
++ * reporting and does not return an error code. In the event of error it will
++ * just call png_error. The input data length may exceed 32-bits. The 'flush'
++ * parameter is exactly the same as that to deflate, with the following
++ * meanings:
++ *
++ * Z_NO_FLUSH: normal incremental output of compressed data
++ * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush
++ * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up
++ *
++ * The routine manages the acquire and release of the png_ptr->zstream by
++ * checking and (at the end) clearing png_ptr->zowner; it does some sanity
++ * checks on the 'mode' flags while doing this.
++ */
+ void /* PRIVATE */
+-png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
++png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
++ png_alloc_size_t input_len, int flush)
+ {
+- PNG_IDAT;
+-
+- png_debug(1, "in png_write_IDAT");
+-
++ if (png_ptr->zowner != png_IDAT)
++ {
++ /* First time. Ensure we have a temporary buffer for compression and
++ * trim the buffer list if it has more than one entry to free memory.
++ * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
++ * created at this point, but the check here is quick and safe.
++ */
++ if (png_ptr->zbuffer_list == NULL)
++ {
++ png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
++ png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
++ png_ptr->zbuffer_list->next = NULL;
++ }
++
++ else
++ png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);
++
++ /* It is a terminal error if we can't claim the zstream. */
++ if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)
++ png_error(png_ptr, png_ptr->zstream.msg);
++
++ /* The output state is maintained in png_ptr->zstream, so it must be
++ * initialized here after the claim.
++ */
++ png_ptr->zstream.next_out = png_ptr->zbuffer_list->output;
++ png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
++ }
++
++ /* Now loop reading and writing until all the input is consumed or an error
++ * terminates the operation. The _out values are maintained across calls to
++ * this function, but the input must be reset each time.
++ */
++ png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
++ png_ptr->zstream.avail_in = 0; /* set below */
++ for (;;)
++ {
++ int ret;
++
++ /* INPUT: from the row data */
++ uInt avail = ZLIB_IO_MAX;
++
++ if (avail > input_len)
++ avail = (uInt)input_len; /* safe because of the check */
++
++ png_ptr->zstream.avail_in = avail;
++ input_len -= avail;
++
++ ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush);
++
++ /* Include as-yet unconsumed input */
++ input_len += png_ptr->zstream.avail_in;
++ png_ptr->zstream.avail_in = 0;
++
++ /* OUTPUT: write complete IDAT chunks when avail_out drops to zero. Note
++ * that these two zstream fields are preserved across the calls, therefore
++ * there is no need to set these up on entry to the loop.
++ */
++ if (png_ptr->zstream.avail_out == 0)
++ {
++ png_bytep data = png_ptr->zbuffer_list->output;
++ uInt size = png_ptr->zbuffer_size;
++
++ /* Write an IDAT containing the data then reset the buffer. The
++ * first IDAT may need deflate header optimization.
++ */
+ #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
+- if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
+- png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
+- {
+- /* Optimize the CMF field in the zlib stream. This hack of the zlib
+- * stream is compliant to the stream specification.
++ if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
++ png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
++ optimize_cmf(data, png_image_size(png_ptr));
++#endif
++
++ png_write_complete_chunk(png_ptr, png_IDAT, data, size);
++ png_ptr->mode |= PNG_HAVE_IDAT;
++
++ png_ptr->zstream.next_out = data;
++ png_ptr->zstream.avail_out = size;
++
++ /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
++ * the same flush parameter until it has finished output, for NO_FLUSH
++ * it doesn't matter.
++ */
++ if (ret == Z_OK && flush != Z_NO_FLUSH)
++ continue;
++ }
++
++ /* The order of these checks doesn't matter much; it just affects which
++ * possible error might be detected if multiple things go wrong at once.
+ */
+- unsigned int z_cmf = data[0]; /* zlib compression method and flags */
+-
+- if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
++ if (ret == Z_OK) /* most likely return code! */
+ {
+- /* Avoid memory underflows and multiplication overflows.
+- *
+- * The conditions below are practically always satisfied;
+- * however, they still must be checked.
++ /* If all the input has been consumed then just return. If Z_FINISH
++ * was used as the flush parameter something has gone wrong if we get
++ * here.
+ */
+- if (length >= 2 &&
+- png_ptr->height < 16384 && png_ptr->width < 16384)
++ if (input_len == 0)
+ {
+- /* Compute the maximum possible length of the datastream */
+-
+- /* Number of pixels, plus for each row a filter byte
+- * and possibly a padding byte, so increase the maximum
+- * size to account for these.
+- */
+- unsigned int z_cinfo;
+- unsigned int half_z_window_size;
+- png_uint_32 uncompressed_idat_size = png_ptr->height *
+- ((png_ptr->width *
+- png_ptr->channels * png_ptr->bit_depth + 15) >> 3);
+-
+- /* If it's interlaced, each block of 8 rows is sent as up to
+- * 14 rows, i.e., 6 additional rows, each with a filter byte
+- * and possibly a padding byte
+- */
+- if (png_ptr->interlaced)
+- uncompressed_idat_size += ((png_ptr->height + 7)/8) *
+- (png_ptr->bit_depth < 8 ? 12 : 6);
+-
+- z_cinfo = z_cmf >> 4;
+- half_z_window_size = 1 << (z_cinfo + 7);
+-
+- while (uncompressed_idat_size <= half_z_window_size &&
+- half_z_window_size >= 256)
+- {
+- z_cinfo--;
+- half_z_window_size >>= 1;
+- }
+-
+- z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
+-
+- if (data[0] != z_cmf)
+- {
+- int tmp;
+- data[0] = (png_byte)z_cmf;
+- tmp = data[1] & 0xe0;
+- tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
+- data[1] = (png_byte)tmp;
+- }
++ if (flush == Z_FINISH)
++ png_error(png_ptr, "Z_OK on Z_FINISH with output space");
++
++ return;
+ }
+ }
+
++ else if (ret == Z_STREAM_END && flush == Z_FINISH)
++ {
++ /* This is the end of the IDAT data; any pending output must be
++ * flushed. For small PNG files we may still be at the beginning.
++ */
++ png_bytep data = png_ptr->zbuffer_list->output;
++ uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
++
++#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
++ if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
++ png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
++ optimize_cmf(data, png_image_size(png_ptr));
++#endif
++
++ png_write_complete_chunk(png_ptr, png_IDAT, data, size);
++ png_ptr->zstream.avail_out = 0;
++ png_ptr->zstream.next_out = NULL;
++ png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT;
++
++ png_ptr->zowner = 0; /* Release the stream */
++ return;
++ }
++
+ else
+- png_error(png_ptr,
+- "Invalid zlib compression method or flags in IDAT");
++ {
++ /* This is an error condition. */
++ png_zstream_error(png_ptr, ret);
++ png_error(png_ptr, png_ptr->zstream.msg);
++ }
+ }
+-#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */
+-
+- png_write_chunk(png_ptr, png_IDAT, data, length);
+- png_ptr->mode |= PNG_HAVE_IDAT;
+-
+- /* Prior to 1.5.4 this code was replicated in every caller (except at the
+- * end, where it isn't technically necessary). Since this function has
+- * flushed the data we can safely reset the zlib output buffer here.
+- */
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+ }
+
+ /* Write an IEND chunk */
+ void /* PRIVATE */
+-png_write_IEND(png_structp png_ptr)
++png_write_IEND(png_structrp png_ptr)
+ {
+- PNG_IEND;
+-
+ png_debug(1, "in png_write_IEND");
+
+- png_write_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
++ png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
+ png_ptr->mode |= PNG_HAVE_IEND;
+ }
+
+ #ifdef PNG_WRITE_gAMA_SUPPORTED
+ /* Write a gAMA chunk */
+ void /* PRIVATE */
+-png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
++png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma)
+ {
+- PNG_gAMA;
+ png_byte buf[4];
+
+ png_debug(1, "in png_write_gAMA");
+
+ /* file_gamma is saved in 1/100,000ths */
+ png_save_uint_32(buf, (png_uint_32)file_gamma);
+- png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
++ png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_sRGB_SUPPORTED
+ /* Write a sRGB chunk */
+ void /* PRIVATE */
+-png_write_sRGB(png_structp png_ptr, int srgb_intent)
++png_write_sRGB(png_structrp png_ptr, int srgb_intent)
+ {
+- PNG_sRGB;
+ png_byte buf[1];
+
+ png_debug(1, "in png_write_sRGB");
+@@ -1096,104 +1210,79 @@
+ "Invalid sRGB rendering intent specified");
+
+ buf[0]=(png_byte)srgb_intent;
+- png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
++ png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_iCCP_SUPPORTED
+ /* Write an iCCP chunk */
+ void /* PRIVATE */
+-png_write_iCCP(png_structp png_ptr, png_const_charp name, int compression_type,
+- png_const_charp profile, int profile_len)
++png_write_iCCP(png_structrp png_ptr, png_const_charp name,
++ png_const_bytep profile)
+ {
+- PNG_iCCP;
+- png_size_t name_len;
+- png_charp new_name;
++ png_uint_32 name_len;
++ png_uint_32 profile_len;
++ png_byte new_name[81]; /* 1 byte for the compression byte */
+ compression_state comp;
+- int embedded_profile_len = 0;
++ png_uint_32 temp;
+
+ png_debug(1, "in png_write_iCCP");
+
+- comp.num_output_ptr = 0;
+- comp.max_output_ptr = 0;
+- comp.output_ptr = NULL;
+- comp.input = NULL;
+- comp.input_len = 0;
+-
+- if ((name_len = png_check_keyword(png_ptr, name, &new_name)) == 0)
+- return;
+-
+- if (compression_type != PNG_COMPRESSION_TYPE_BASE)
+- png_warning(png_ptr, "Unknown compression type in iCCP chunk");
+-
++ /* These are all internal problems: the profile should have been checked
++ * before when it was stored.
++ */
+ if (profile == NULL)
+- profile_len = 0;
+-
+- if (profile_len > 3)
+- embedded_profile_len =
+- ((*( (png_const_bytep)profile ))<<24) |
+- ((*( (png_const_bytep)profile + 1))<<16) |
+- ((*( (png_const_bytep)profile + 2))<< 8) |
+- ((*( (png_const_bytep)profile + 3)) );
+-
+- if (embedded_profile_len < 0)
++ png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
++
++ profile_len = png_get_uint_32(profile);
++
++ if (profile_len < 132)
++ png_error(png_ptr, "ICC profile too short");
++
++ temp = (png_uint_32) (*(profile+8));
++ if (temp > 3 && (profile_len & 0x03))
++ png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
++
+ {
+- png_warning(png_ptr,
+- "Embedded profile length in iCCP chunk is negative");
+-
+- png_free(png_ptr, new_name);
+- return;
++ png_uint_32 embedded_profile_len = png_get_uint_32(profile);
++
++ if (profile_len != embedded_profile_len)
++ png_error(png_ptr, "Profile length does not match profile");
+ }
+
+- if (profile_len < embedded_profile_len)
+- {
+- png_warning(png_ptr,
+- "Embedded profile length too large in iCCP chunk");
+-
+- png_free(png_ptr, new_name);
+- return;
+- }
+-
+- if (profile_len > embedded_profile_len)
+- {
+- png_warning(png_ptr,
+- "Truncating profile to actual length in iCCP chunk");
+-
+- profile_len = embedded_profile_len;
+- }
+-
+- if (profile_len)
+- profile_len = png_text_compress(png_ptr, profile,
+- (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
++ name_len = png_check_keyword(png_ptr, name, new_name);
++
++ if (name_len == 0)
++ png_error(png_ptr, "iCCP: invalid keyword");
++
++ new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE;
+
+ /* Make sure we include the NULL after the name and the compression type */
+- png_write_chunk_start(png_ptr, png_iCCP,
+- (png_uint_32)(name_len + profile_len + 2));
+-
+- new_name[name_len + 1] = 0x00;
+-
+- png_write_chunk_data(png_ptr, (png_bytep)new_name,
+- (png_size_t)(name_len + 2));
+-
+- if (profile_len)
+- {
+- comp.input_len = profile_len;
+- png_write_compressed_data_out(png_ptr, &comp);
+- }
++ ++name_len;
++
++ png_text_compress_init(&comp, profile, profile_len);
++
++ /* Allow for keyword terminator and compression byte */
++ if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK)
++ png_error(png_ptr, png_ptr->zstream.msg);
++
++ png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len);
++
++ png_write_chunk_data(png_ptr, new_name, name_len);
++
++ png_write_compressed_data_out(png_ptr, &comp);
+
+ png_write_chunk_end(png_ptr);
+- png_free(png_ptr, new_name);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_sPLT_SUPPORTED
+ /* Write a sPLT chunk */
+ void /* PRIVATE */
+-png_write_sPLT(png_structp png_ptr, png_const_sPLT_tp spalette)
++png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
+ {
+- PNG_sPLT;
+- png_size_t name_len;
+- png_charp new_name;
++ png_uint_32 name_len;
++ png_byte new_name[80];
+ png_byte entrybuf[10];
+ png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);
+ png_size_t palette_size = entry_size * spalette->nentries;
+@@ -1204,11 +1293,13 @@
+
+ png_debug(1, "in png_write_sPLT");
+
+- if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0)
+- return;
++ name_len = png_check_keyword(png_ptr, spalette->name, new_name);
++
++ if (name_len == 0)
++ png_error(png_ptr, "sPLT: invalid keyword");
+
+ /* Make sure we include the NULL after the name */
+- png_write_chunk_start(png_ptr, png_sPLT,
++ png_write_chunk_header(png_ptr, png_sPLT,
+ (png_uint_32)(name_len + 2 + palette_size));
+
+ png_write_chunk_data(png_ptr, (png_bytep)new_name,
+@@ -1238,7 +1329,7 @@
+ png_save_uint_16(entrybuf + 8, ep->frequency);
+ }
+
+- png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
++ png_write_chunk_data(png_ptr, entrybuf, entry_size);
+ }
+ #else
+ ep=spalette->entries;
+@@ -1262,28 +1353,26 @@
+ png_save_uint_16(entrybuf + 8, ep[i].frequency);
+ }
+
+- png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
++ png_write_chunk_data(png_ptr, entrybuf, entry_size);
+ }
+ #endif
+
+ png_write_chunk_end(png_ptr);
+- png_free(png_ptr, new_name);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_sBIT_SUPPORTED
+ /* Write the sBIT chunk */
+ void /* PRIVATE */
+-png_write_sBIT(png_structp png_ptr, png_const_color_8p sbit, int color_type)
++png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
+ {
+- PNG_sBIT;
+ png_byte buf[4];
+ png_size_t size;
+
+ png_debug(1, "in png_write_sBIT");
+
+ /* Make sure we don't depend upon the order of PNG_COLOR_8 */
+- if (color_type & PNG_COLOR_MASK_COLOR)
++ if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+ png_byte maxbits;
+
+@@ -1316,7 +1405,7 @@
+ size = 1;
+ }
+
+- if (color_type & PNG_COLOR_MASK_ALPHA)
++ if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
+ {
+ if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
+ {
+@@ -1327,53 +1416,42 @@
+ buf[size++] = sbit->alpha;
+ }
+
+- png_write_chunk(png_ptr, png_sBIT, buf, size);
++ png_write_complete_chunk(png_ptr, png_sBIT, buf, size);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_cHRM_SUPPORTED
+ /* Write the cHRM chunk */
+ void /* PRIVATE */
+-png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
+- png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,
+- png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,
+- png_fixed_point blue_y)
++png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy)
+ {
+- PNG_cHRM;
+ png_byte buf[32];
+
+ png_debug(1, "in png_write_cHRM");
+
+ /* Each value is saved in 1/100,000ths */
+-#ifdef PNG_CHECK_cHRM_SUPPORTED
+- if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,
+- green_x, green_y, blue_x, blue_y))
+-#endif
+- {
+- png_save_uint_32(buf, (png_uint_32)white_x);
+- png_save_uint_32(buf + 4, (png_uint_32)white_y);
+-
+- png_save_uint_32(buf + 8, (png_uint_32)red_x);
+- png_save_uint_32(buf + 12, (png_uint_32)red_y);
+-
+- png_save_uint_32(buf + 16, (png_uint_32)green_x);
+- png_save_uint_32(buf + 20, (png_uint_32)green_y);
+-
+- png_save_uint_32(buf + 24, (png_uint_32)blue_x);
+- png_save_uint_32(buf + 28, (png_uint_32)blue_y);
+-
+- png_write_chunk(png_ptr, png_cHRM, buf, (png_size_t)32);
+- }
++ png_save_int_32(buf, xy->whitex);
++ png_save_int_32(buf + 4, xy->whitey);
++
++ png_save_int_32(buf + 8, xy->redx);
++ png_save_int_32(buf + 12, xy->redy);
++
++ png_save_int_32(buf + 16, xy->greenx);
++ png_save_int_32(buf + 20, xy->greeny);
++
++ png_save_int_32(buf + 24, xy->bluex);
++ png_save_int_32(buf + 28, xy->bluey);
++
++ png_write_complete_chunk(png_ptr, png_cHRM, buf, 32);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_tRNS_SUPPORTED
+ /* Write the tRNS chunk */
+ void /* PRIVATE */
+-png_write_tRNS(png_structp png_ptr, png_const_bytep trans_alpha,
++png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
+ png_const_color_16p tran, int num_trans, int color_type)
+ {
+- PNG_tRNS;
+ png_byte buf[6];
+
+ png_debug(1, "in png_write_tRNS");
+@@ -1382,12 +1460,14 @@
+ {
+ 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;
+ }
+
+ /* Write the chunk out as it is */
+- png_write_chunk(png_ptr, png_tRNS, trans_alpha, (png_size_t)num_trans);
++ png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
++ (png_size_t)num_trans);
+ }
+
+ else if (color_type == PNG_COLOR_TYPE_GRAY)
+@@ -1395,14 +1475,14 @@
+ /* 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;
+ }
+
+ png_save_uint_16(buf, tran->gray);
+- png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
++ png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
+ }
+
+ else if (color_type == PNG_COLOR_TYPE_RGB)
+@@ -1412,22 +1492,22 @@
+ png_save_uint_16(buf + 2, tran->green);
+ png_save_uint_16(buf + 4, tran->blue);
+ #ifdef PNG_WRITE_16BIT_SUPPORTED
+- if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
++ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
+ #else
+- if (buf[0] | buf[2] | buf[4])
++ if ((buf[0] | buf[2] | buf[4]) != 0)
+ #endif
+ {
+- png_warning(png_ptr,
++ png_app_warning(png_ptr,
+ "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
+ return;
+ }
+
+- png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
++ png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
+ }
+
+ 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
+@@ -1435,9 +1515,8 @@
+ #ifdef PNG_WRITE_bKGD_SUPPORTED
+ /* Write the background chunk */
+ void /* PRIVATE */
+-png_write_bKGD(png_structp png_ptr, png_const_color_16p back, int color_type)
++png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
+ {
+- PNG_bKGD;
+ png_byte buf[6];
+
+ png_debug(1, "in png_write_bKGD");
+@@ -1446,8 +1525,8 @@
+ {
+ if (
+ #ifdef PNG_MNG_FEATURES_SUPPORTED
+- (png_ptr->num_palette ||
+- (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
++ (png_ptr->num_palette != 0 ||
++ (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0) &&
+ #endif
+ back->index >= png_ptr->num_palette)
+ {
+@@ -1456,18 +1535,18 @@
+ }
+
+ buf[0] = back->index;
+- png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
++ png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
+ }
+
+- else if (color_type & PNG_COLOR_MASK_COLOR)
++ else if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
+ {
+ png_save_uint_16(buf, back->red);
+ png_save_uint_16(buf + 2, back->green);
+ png_save_uint_16(buf + 4, back->blue);
+ #ifdef PNG_WRITE_16BIT_SUPPORTED
+- if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
++ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
+ #else
+- if (buf[0] | buf[2] | buf[4])
++ if ((buf[0] | buf[2] | buf[4]) != 0)
+ #endif
+ {
+ png_warning(png_ptr,
+@@ -1476,7 +1555,7 @@
+ return;
+ }
+
+- png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
++ png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
+ }
+
+ else
+@@ -1490,7 +1569,7 @@
+ }
+
+ png_save_uint_16(buf, back->gray);
+- png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
++ png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
+ }
+ }
+ #endif
+@@ -1498,9 +1577,8 @@
+ #ifdef PNG_WRITE_hIST_SUPPORTED
+ /* Write the histogram */
+ void /* PRIVATE */
+-png_write_hIST(png_structp png_ptr, png_const_uint_16p hist, int num_hist)
++png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
+ {
+- PNG_hIST;
+ int i;
+ png_byte buf[3];
+
+@@ -1515,7 +1593,7 @@
+ return;
+ }
+
+- png_write_chunk_start(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
++ png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
+
+ for (i = 0; i < num_hist; i++)
+ {
+@@ -1527,236 +1605,93 @@
+ }
+ #endif
+
+-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
+- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
+-/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
+- * and if invalid, correct the keyword rather than discarding the entire
+- * chunk. The PNG 1.0 specification requires keywords 1-79 characters in
+- * length, forbids leading or trailing whitespace, multiple internal spaces,
+- * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.
+- *
+- * The new_key is allocated to hold the corrected keyword and must be freed
+- * by the calling routine. This avoids problems with trying to write to
+- * static keywords without having to have duplicate copies of the strings.
+- */
+-png_size_t /* PRIVATE */
+-png_check_keyword(png_structp png_ptr, png_const_charp key, png_charpp new_key)
+-{
+- png_size_t key_len;
+- png_const_charp ikp;
+- png_charp kp, dp;
+- int kflag;
+- int kwarn=0;
+-
+- png_debug(1, "in png_check_keyword");
+-
+- *new_key = NULL;
+-
+- if (key == NULL || (key_len = png_strlen(key)) == 0)
+- {
+- png_warning(png_ptr, "zero length keyword");
+- return ((png_size_t)0);
+- }
+-
+- png_debug1(2, "Keyword to be checked is '%s'", key);
+-
+- *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));
+-
+- if (*new_key == NULL)
+- {
+- png_warning(png_ptr, "Out of memory while procesing keyword");
+- return ((png_size_t)0);
+- }
+-
+- /* Replace non-printing characters with a blank and print a warning */
+- for (ikp = key, dp = *new_key; *ikp != '\0'; ikp++, dp++)
+- {
+- if ((png_byte)*ikp < 0x20 ||
+- ((png_byte)*ikp > 0x7E && (png_byte)*ikp < 0xA1))
+- {
+- PNG_WARNING_PARAMETERS(p)
+-
+- png_warning_parameter_unsigned(p, 1, PNG_NUMBER_FORMAT_02x,
+- (png_byte)*ikp);
+- png_formatted_warning(png_ptr, p, "invalid keyword character 0x@1");
+- *dp = ' ';
+- }
+-
+- else
+- {
+- *dp = *ikp;
+- }
+- }
+- *dp = '\0';
+-
+- /* Remove any trailing white space. */
+- kp = *new_key + key_len - 1;
+- if (*kp == ' ')
+- {
+- png_warning(png_ptr, "trailing spaces removed from keyword");
+-
+- while (*kp == ' ')
+- {
+- *(kp--) = '\0';
+- key_len--;
+- }
+- }
+-
+- /* Remove any leading white space. */
+- kp = *new_key;
+- if (*kp == ' ')
+- {
+- png_warning(png_ptr, "leading spaces removed from keyword");
+-
+- while (*kp == ' ')
+- {
+- kp++;
+- key_len--;
+- }
+- }
+-
+- png_debug1(2, "Checking for multiple internal spaces in '%s'", kp);
+-
+- /* Remove multiple internal spaces. */
+- for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)
+- {
+- if (*kp == ' ' && kflag == 0)
+- {
+- *(dp++) = *kp;
+- kflag = 1;
+- }
+-
+- else if (*kp == ' ')
+- {
+- key_len--;
+- kwarn = 1;
+- }
+-
+- else
+- {
+- *(dp++) = *kp;
+- kflag = 0;
+- }
+- }
+- *dp = '\0';
+- if (kwarn)
+- png_warning(png_ptr, "extra interior spaces removed from keyword");
+-
+- if (key_len == 0)
+- {
+- png_free(png_ptr, *new_key);
+- png_warning(png_ptr, "Zero length keyword");
+- }
+-
+- if (key_len > 79)
+- {
+- png_warning(png_ptr, "keyword length must be 1 - 79 characters");
+- (*new_key)[79] = '\0';
+- key_len = 79;
+- }
+-
+- return (key_len);
+-}
+-#endif
+-
+ #ifdef PNG_WRITE_tEXt_SUPPORTED
+ /* Write a tEXt chunk */
+ void /* PRIVATE */
+-png_write_tEXt(png_structp png_ptr, png_const_charp key, png_const_charp text,
++png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
+ png_size_t text_len)
+ {
+- PNG_tEXt;
+- png_size_t key_len;
+- png_charp new_key;
++ png_uint_32 key_len;
++ png_byte new_key[80];
+
+ png_debug(1, "in png_write_tEXt");
+
+- if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)
+- return;
++ key_len = png_check_keyword(png_ptr, key, new_key);
++
++ if (key_len == 0)
++ png_error(png_ptr, "tEXt: invalid keyword");
+
+ if (text == NULL || *text == '\0')
+ text_len = 0;
+
+ else
+- text_len = png_strlen(text);
++ text_len = strlen(text);
++
++ if (text_len > PNG_UINT_31_MAX - (key_len+1))
++ png_error(png_ptr, "tEXt: text too long");
+
+ /* Make sure we include the 0 after the key */
+- png_write_chunk_start(png_ptr, png_tEXt,
+- (png_uint_32)(key_len + text_len + 1));
++ png_write_chunk_header(png_ptr, png_tEXt,
++ (png_uint_32)/*checked above*/(key_len + text_len + 1));
+ /*
+ * We leave it to the application to meet PNG-1.0 requirements on the
+ * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
+ * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
+ * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
+ */
+- png_write_chunk_data(png_ptr, (png_bytep)new_key,
+- (png_size_t)(key_len + 1));
+-
+- if (text_len)
+- png_write_chunk_data(png_ptr, (png_const_bytep)text,
+- (png_size_t)text_len);
++ png_write_chunk_data(png_ptr, new_key, key_len + 1);
++
++ if (text_len != 0)
++ png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len);
+
+ png_write_chunk_end(png_ptr);
+- png_free(png_ptr, new_key);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_zTXt_SUPPORTED
+ /* Write a compressed text chunk */
+ void /* PRIVATE */
+-png_write_zTXt(png_structp png_ptr, png_const_charp key, png_const_charp text,
+- png_size_t text_len, int compression)
++png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
++ int compression)
+ {
+- PNG_zTXt;
+- png_size_t key_len;
+- png_byte buf;
+- png_charp new_key;
++ png_uint_32 key_len;
++ png_byte new_key[81];
+ compression_state comp;
+
+ png_debug(1, "in png_write_zTXt");
+
+- comp.num_output_ptr = 0;
+- comp.max_output_ptr = 0;
+- comp.output_ptr = NULL;
+- comp.input = NULL;
+- comp.input_len = 0;
+-
+- if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0)
++ if (compression == PNG_TEXT_COMPRESSION_NONE)
+ {
+- png_free(png_ptr, new_key);
++ png_write_tEXt(png_ptr, key, text, 0);
+ return;
+ }
+
+- if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)
+- {
+- png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);
+- png_free(png_ptr, new_key);
+- return;
+- }
+-
+- text_len = png_strlen(text);
++ if (compression != PNG_TEXT_COMPRESSION_zTXt)
++ png_error(png_ptr, "zTXt: invalid compression type");
++
++ key_len = png_check_keyword(png_ptr, key, new_key);
++
++ if (key_len == 0)
++ png_error(png_ptr, "zTXt: invalid keyword");
++
++ /* Add the compression method and 1 for the keyword separator. */
++ new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
++ ++key_len;
+
+ /* Compute the compressed data; do it now for the length */
+- text_len = png_text_compress(png_ptr, text, text_len, compression,
+- &comp);
++ png_text_compress_init(&comp, (png_const_bytep)text,
++ text == NULL ? 0 : strlen(text));
++
++ if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
++ png_error(png_ptr, png_ptr->zstream.msg);
+
+ /* Write start of chunk */
+- png_write_chunk_start(png_ptr, png_zTXt,
+- (png_uint_32)(key_len+text_len + 2));
++ png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len);
+
+ /* Write key */
+- png_write_chunk_data(png_ptr, (png_bytep)new_key,
+- (png_size_t)(key_len + 1));
+-
+- png_free(png_ptr, new_key);
+-
+- buf = (png_byte)compression;
+-
+- /* Write compression */
+- png_write_chunk_data(png_ptr, &buf, (png_size_t)1);
++ png_write_chunk_data(png_ptr, new_key, key_len);
+
+ /* Write the compressed data */
+- comp.input_len = text_len;
+ png_write_compressed_data_out(png_ptr, &comp);
+
+ /* Close the chunk */
+@@ -1767,104 +1702,109 @@
+ #ifdef PNG_WRITE_iTXt_SUPPORTED
+ /* Write an iTXt chunk */
+ void /* PRIVATE */
+-png_write_iTXt(png_structp png_ptr, int compression, png_const_charp key,
++png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key,
+ png_const_charp lang, png_const_charp lang_key, png_const_charp text)
+ {
+- PNG_iTXt;
+- png_size_t lang_len, key_len, lang_key_len, text_len;
+- png_charp new_lang;
+- png_charp new_key = NULL;
+- png_byte cbuf[2];
++ png_uint_32 key_len, prefix_len;
++ png_size_t lang_len, lang_key_len;
++ png_byte new_key[82];
+ compression_state comp;
+
+ png_debug(1, "in png_write_iTXt");
+
+- comp.num_output_ptr = 0;
+- comp.max_output_ptr = 0;
+- comp.output_ptr = NULL;
+- comp.input = NULL;
+-
+- if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0)
+- return;
+-
+- if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang)) == 0)
++ key_len = png_check_keyword(png_ptr, key, new_key);
++
++ if (key_len == 0)
++ png_error(png_ptr, "iTXt: invalid keyword");
++
++ /* Set the compression flag */
++ switch (compression)
+ {
+- png_warning(png_ptr, "Empty language field in iTXt chunk");
+- new_lang = NULL;
+- lang_len = 0;
++ case PNG_ITXT_COMPRESSION_NONE:
++ case PNG_TEXT_COMPRESSION_NONE:
++ compression = new_key[++key_len] = 0; /* no compression */
++ break;
++
++ case PNG_TEXT_COMPRESSION_zTXt:
++ case PNG_ITXT_COMPRESSION_zTXt:
++ compression = new_key[++key_len] = 1; /* compressed */
++ break;
++
++ default:
++ png_error(png_ptr, "iTXt: invalid compression");
+ }
+
+- if (lang_key == NULL)
+- lang_key_len = 0;
+-
+- else
+- lang_key_len = png_strlen(lang_key);
+-
+- if (text == NULL)
+- text_len = 0;
+-
+- else
+- text_len = png_strlen(text);
+-
+- /* Compute the compressed data; do it now for the length */
+- text_len = png_text_compress(png_ptr, text, text_len, compression - 2,
+- &comp);
+-
+-
+- /* Make sure we include the compression flag, the compression byte,
+- * and the NULs after the key, lang, and lang_key parts
+- */
+-
+- png_write_chunk_start(png_ptr, png_iTXt, (png_uint_32)(
+- 5 /* comp byte, comp flag, terminators for key, lang and lang_key */
+- + key_len
+- + lang_len
+- + lang_key_len
+- + text_len));
++ new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
++ ++key_len; /* for the keywod separator */
+
+ /* We leave it to the application to meet PNG-1.0 requirements on the
+ * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
+- * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
++ * any non-Latin-1 characters except for NEWLINE. ISO PNG, however,
++ * specifies that the text is UTF-8 and this really doesn't require any
++ * checking.
++ *
+ * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
++ *
++ * TODO: validate the language tag correctly (see the spec.)
+ */
+- png_write_chunk_data(png_ptr, (png_bytep)new_key, (png_size_t)(key_len + 1));
+-
+- /* Set the compression flag */
+- if (compression == PNG_ITXT_COMPRESSION_NONE ||
+- compression == PNG_TEXT_COMPRESSION_NONE)
+- cbuf[0] = 0;
+-
+- else /* compression == PNG_ITXT_COMPRESSION_zTXt */
+- cbuf[0] = 1;
+-
+- /* Set the compression method */
+- cbuf[1] = 0;
+-
+- png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);
+-
+- cbuf[0] = 0;
+- png_write_chunk_data(png_ptr, (new_lang ? (png_const_bytep)new_lang : cbuf),
+- (png_size_t)(lang_len + 1));
+-
+- png_write_chunk_data(png_ptr, (lang_key ? (png_const_bytep)lang_key : cbuf),
+- (png_size_t)(lang_key_len + 1));
+-
+- png_write_compressed_data_out(png_ptr, &comp);
++ if (lang == NULL) lang = ""; /* empty language is valid */
++ lang_len = strlen(lang)+1;
++ if (lang_key == NULL) lang_key = ""; /* may be empty */
++ lang_key_len = strlen(lang_key)+1;
++ if (text == NULL) text = ""; /* may be empty */
++
++ prefix_len = key_len;
++ if (lang_len > PNG_UINT_31_MAX-prefix_len)
++ prefix_len = PNG_UINT_31_MAX;
++ else
++ prefix_len = (png_uint_32)(prefix_len + lang_len);
++
++ if (lang_key_len > PNG_UINT_31_MAX-prefix_len)
++ prefix_len = PNG_UINT_31_MAX;
++ else
++ prefix_len = (png_uint_32)(prefix_len + lang_key_len);
++
++ png_text_compress_init(&comp, (png_const_bytep)text, strlen(text));
++
++ if (compression != 0)
++ {
++ if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK)
++ png_error(png_ptr, png_ptr->zstream.msg);
++ }
++
++ else
++ {
++ if (comp.input_len > PNG_UINT_31_MAX-prefix_len)
++ png_error(png_ptr, "iTXt: uncompressed text too long");
++
++ /* So the string will fit in a chunk: */
++ comp.output_len = (png_uint_32)/*SAFE*/comp.input_len;
++ }
++
++ png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len);
++
++ png_write_chunk_data(png_ptr, new_key, key_len);
++
++ png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len);
++
++ png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len);
++
++ if (compression != 0)
++ png_write_compressed_data_out(png_ptr, &comp);
++
++ else
++ png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.input_len);
+
+ png_write_chunk_end(png_ptr);
+-
+- png_free(png_ptr, new_key);
+- png_free(png_ptr, new_lang);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_oFFs_SUPPORTED
+ /* Write the oFFs chunk */
+ void /* PRIVATE */
+-png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
++png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
+ int unit_type)
+ {
+- PNG_oFFs;
+ png_byte buf[9];
+
+ png_debug(1, "in png_write_oFFs");
+@@ -1876,52 +1816,57 @@
+ png_save_int_32(buf + 4, y_offset);
+ buf[8] = (png_byte)unit_type;
+
+- png_write_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
++ png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
+ }
+ #endif
+ #ifdef PNG_WRITE_pCAL_SUPPORTED
+ /* Write the pCAL chunk (described in the PNG extensions document) */
+ void /* PRIVATE */
+-png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
++png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
+ png_int_32 X1, int type, int nparams, png_const_charp units,
+ png_charpp params)
+ {
+- PNG_pCAL;
+- png_size_t purpose_len, units_len, total_len;
+- png_uint_32p params_len;
++ png_uint_32 purpose_len;
++ png_size_t units_len, total_len;
++ png_size_tp params_len;
+ png_byte buf[10];
+- png_charp new_purpose;
++ png_byte new_purpose[80];
+ int i;
+
+ png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
+
+ if (type >= PNG_EQUATION_LAST)
+- png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
+-
+- purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;
++ png_error(png_ptr, "Unrecognized equation type for pCAL chunk");
++
++ purpose_len = png_check_keyword(png_ptr, purpose, new_purpose);
++
++ if (purpose_len == 0)
++ png_error(png_ptr, "pCAL: invalid keyword");
++
++ ++purpose_len; /* terminator */
++
+ png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
+- units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);
++ units_len = strlen(units) + (nparams == 0 ? 0 : 1);
+ png_debug1(3, "pCAL units length = %d", (int)units_len);
+ total_len = purpose_len + units_len + 10;
+
+- params_len = (png_uint_32p)png_malloc(png_ptr,
+- (png_alloc_size_t)(nparams * png_sizeof(png_uint_32)));
++ params_len = (png_size_tp)png_malloc(png_ptr,
++ (png_alloc_size_t)(nparams * (sizeof (png_size_t))));
+
+ /* Find the length of each parameter, making sure we don't count the
+ * null terminator for the last parameter.
+ */
+ for (i = 0; i < nparams; i++)
+ {
+- params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
++ params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
+ png_debug2(3, "pCAL parameter %d length = %lu", i,
+ (unsigned long)params_len[i]);
+- total_len += (png_size_t)params_len[i];
++ total_len += params_len[i];
+ }
+
+ png_debug1(3, "pCAL total length = %d", (int)total_len);
+- png_write_chunk_start(png_ptr, png_pCAL, (png_uint_32)total_len);
+- png_write_chunk_data(png_ptr, (png_const_bytep)new_purpose,
+- (png_size_t)purpose_len);
++ png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len);
++ png_write_chunk_data(png_ptr, new_purpose, purpose_len);
+ png_save_int_32(buf, X0);
+ png_save_int_32(buf + 4, X1);
+ buf[8] = (png_byte)type;
+@@ -1929,12 +1874,9 @@
+ png_write_chunk_data(png_ptr, buf, (png_size_t)10);
+ png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
+
+- png_free(png_ptr, new_purpose);
+-
+ for (i = 0; i < nparams; i++)
+ {
+- png_write_chunk_data(png_ptr, (png_const_bytep)params[i],
+- (png_size_t)params_len[i]);
++ png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]);
+ }
+
+ png_free(png_ptr, params_len);
+@@ -1945,17 +1887,16 @@
+ #ifdef PNG_WRITE_sCAL_SUPPORTED
+ /* Write the sCAL chunk */
+ void /* PRIVATE */
+-png_write_sCAL_s(png_structp png_ptr, int unit, png_const_charp width,
++png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
+ png_const_charp height)
+ {
+- PNG_sCAL;
+ png_byte buf[64];
+ png_size_t wlen, hlen, total_len;
+
+ png_debug(1, "in png_write_sCAL_s");
+
+- wlen = png_strlen(width);
+- hlen = png_strlen(height);
++ wlen = strlen(width);
++ hlen = strlen(height);
+ total_len = wlen + hlen + 2;
+
+ if (total_len > 64)
+@@ -1965,22 +1906,21 @@
+ }
+
+ buf[0] = (png_byte)unit;
+- png_memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */
+- png_memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */
++ memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */
++ memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */
+
+ png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
+- png_write_chunk(png_ptr, png_sCAL, buf, total_len);
++ png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len);
+ }
+ #endif
+
+ #ifdef PNG_WRITE_pHYs_SUPPORTED
+ /* Write the pHYs chunk */
+ void /* PRIVATE */
+-png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
++png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
+ png_uint_32 y_pixels_per_unit,
+ int unit_type)
+ {
+- PNG_pHYs;
+ png_byte buf[9];
+
+ png_debug(1, "in png_write_pHYs");
+@@ -1992,7 +1932,7 @@
+ png_save_uint_32(buf + 4, y_pixels_per_unit);
+ buf[8] = (png_byte)unit_type;
+
+- png_write_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
++ png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
+ }
+ #endif
+
+@@ -2001,9 +1941,8 @@
+ * or png_convert_from_time_t(), or fill in the structure yourself.
+ */
+ void /* PRIVATE */
+-png_write_tIME(png_structp png_ptr, png_const_timep mod_time)
++png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
+ {
+- PNG_tIME;
+ png_byte buf[7];
+
+ png_debug(1, "in png_write_tIME");
+@@ -2023,40 +1962,44 @@
+ buf[5] = mod_time->minute;
+ buf[6] = mod_time->second;
+
+- png_write_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
++ png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
+ }
+ #endif
+
+ /* Initializes the row writing capability of libpng */
+ void /* PRIVATE */
+-png_write_start_row(png_structp png_ptr)
++png_write_start_row(png_structrp png_ptr)
+ {
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* Start of interlace block */
+- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
++ static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* Offset to next interlace block */
+- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* Start of interlace block in the y direction */
+- int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
++ static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* Offset to next interlace block in the y direction */
+- int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
++ static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+ #endif
+
+- png_size_t buf_size;
++ png_alloc_size_t buf_size;
++ int usr_pixel_depth;
+
+ png_debug(1, "in png_write_start_row");
+
+- buf_size = (png_size_t)(PNG_ROWBYTES(
+- png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
++ usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
++ buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
++
++ /* 1.5.6: added to allow checking in the row write code. */
++ png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
++ png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
+
+ /* Set up row buffer */
+- png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,
+- (png_alloc_size_t)buf_size);
++ png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
+
+ png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
+
+@@ -2070,13 +2013,13 @@
+ }
+
+ /* We only need to keep the previous row if we are using one of these. */
+- if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
++ if ((png_ptr->do_filter &
++ (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
+ {
+ /* Set up previous row buffer */
+- png_ptr->prev_row = (png_bytep)png_calloc(png_ptr,
+- (png_alloc_size_t)buf_size);
+-
+- if (png_ptr->do_filter & PNG_FILTER_UP)
++ png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size);
++
++ if ((png_ptr->do_filter & PNG_FILTER_UP) != 0)
+ {
+ png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
+ png_ptr->rowbytes + 1);
+@@ -2084,7 +2027,7 @@
+ png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
+ }
+
+- if (png_ptr->do_filter & PNG_FILTER_AVG)
++ if ((png_ptr->do_filter & PNG_FILTER_AVG) != 0)
+ {
+ png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
+ png_ptr->rowbytes + 1);
+@@ -2092,7 +2035,7 @@
+ png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
+ }
+
+- if (png_ptr->do_filter & PNG_FILTER_PAETH)
++ if ((png_ptr->do_filter & PNG_FILTER_PAETH) != 0)
+ {
+ png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
+ png_ptr->rowbytes + 1);
+@@ -2100,13 +2043,13 @@
+ png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
+ }
+ }
+-#endif /* PNG_WRITE_FILTER_SUPPORTED */
++#endif /* WRITE_FILTER */
+
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* If interlaced, we need to set up width and height of pass */
+- if (png_ptr->interlaced)
++ if (png_ptr->interlaced != 0)
+ {
+- if (!(png_ptr->transformations & PNG_INTERLACE))
++ if ((png_ptr->transformations & PNG_INTERLACE) == 0)
+ {
+ png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
+ png_pass_ystart[0]) / png_pass_yinc[0];
+@@ -2128,34 +2071,28 @@
+ png_ptr->num_rows = png_ptr->height;
+ png_ptr->usr_width = png_ptr->width;
+ }
+-
+- png_zlib_claim(png_ptr, PNG_ZLIB_FOR_IDAT);
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+ }
+
+ /* Internal use only. Called when finished processing a row of data. */
+ void /* PRIVATE */
+-png_write_finish_row(png_structp png_ptr)
++png_write_finish_row(png_structrp png_ptr)
+ {
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* Start of interlace block */
+- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
++ static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* Offset to next interlace block */
+- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ /* Start of interlace block in the y direction */
+- int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
++ static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+ /* Offset to next interlace block in the y direction */
+- int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
++ static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+ #endif
+
+- int ret;
+-
+ png_debug(1, "in png_write_finish_row");
+
+ /* Next row */
+@@ -2167,10 +2104,10 @@
+
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+ /* If interlaced, go to next pass */
+- if (png_ptr->interlaced)
++ if (png_ptr->interlaced != 0)
+ {
+ png_ptr->row_number = 0;
+- if (png_ptr->transformations & PNG_INTERLACE)
++ if ((png_ptr->transformations & PNG_INTERLACE) != 0)
+ {
+ png_ptr->pass++;
+ }
+@@ -2195,7 +2132,7 @@
+ png_pass_ystart[png_ptr->pass]) /
+ png_pass_yinc[png_ptr->pass];
+
+- if (png_ptr->transformations & PNG_INTERLACE)
++ if ((png_ptr->transformations & PNG_INTERLACE) != 0)
+ break;
+
+ } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
+@@ -2206,7 +2143,7 @@
+ if (png_ptr->pass < 7)
+ {
+ if (png_ptr->prev_row != NULL)
+- png_memset(png_ptr->prev_row, 0,
++ memset(png_ptr->prev_row, 0,
+ (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
+ png_ptr->usr_bit_depth, png_ptr->width)) + 1);
+
+@@ -2217,42 +2154,7 @@
+
+ /* If we get here, we've just written the last row, so we need
+ to flush the compressor */
+- do
+- {
+- /* Tell the compressor we are done */
+- ret = deflate(&png_ptr->zstream, Z_FINISH);
+-
+- /* Check for an error */
+- if (ret == Z_OK)
+- {
+- /* Check to see if we need more room */
+- if (!(png_ptr->zstream.avail_out))
+- {
+- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+- png_ptr->zstream.next_out = png_ptr->zbuf;
+- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
+- }
+- }
+-
+- else if (ret != Z_STREAM_END)
+- {
+- if (png_ptr->zstream.msg != NULL)
+- png_error(png_ptr, png_ptr->zstream.msg);
+-
+- else
+- png_error(png_ptr, "zlib error");
+- }
+- } while (ret != Z_STREAM_END);
+-
+- /* Write any extra space */
+- if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
+- {
+- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -
+- png_ptr->zstream.avail_out);
+- }
+-
+- png_zlib_release(png_ptr);
+- png_ptr->zstream.data_type = Z_BINARY;
++ png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH);
+ }
+
+ #ifdef PNG_WRITE_INTERLACING_SUPPORTED
+@@ -2269,10 +2171,10 @@
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+ /* Start of interlace block */
+- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
++ static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+ /* Offset to next interlace block */
+- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
++ static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+ png_debug(1, "in png_do_write_interlace");
+
+@@ -2416,7 +2318,7 @@
+
+ /* Move the pixel */
+ if (dp != sp)
+- png_memcpy(dp, sp, pixel_bytes);
++ memcpy(dp, sp, pixel_bytes);
+
+ /* Next pixel */
+ dp += pixel_bytes;
+@@ -2440,14 +2342,16 @@
+ * been specified by the application, and then writes the row out with the
+ * chosen filter.
+ */
+-static void png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row);
++static void
++png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
++ png_size_t row_bytes);
+
+ #define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)
+ #define PNG_HISHIFT 10
+ #define PNG_LOMASK ((png_uint_32)0xffffL)
+ #define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
+ void /* PRIVATE */
+-png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
++png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
+ {
+ png_bytep best_row;
+ #ifdef PNG_WRITE_FILTER_SUPPORTED
+@@ -2456,7 +2360,7 @@
+ png_byte filter_to_do = png_ptr->do_filter;
+ png_size_t row_bytes = row_info->rowbytes;
+ #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+- int num_p_filters = (int)png_ptr->num_prev_filters;
++ int num_p_filters = png_ptr->num_prev_filters;
+ #endif
+
+ png_debug(1, "in png_write_find_filter");
+@@ -2507,7 +2411,7 @@
+ /* We don't need to test the 'no filter' case if this is the only filter
+ * that has been chosen, as it doesn't actually do anything to the data.
+ */
+- if ((filter_to_do & PNG_FILTER_NONE) && filter_to_do != PNG_FILTER_NONE)
++ if ((filter_to_do & PNG_FILTER_NONE) != 0 && filter_to_do != PNG_FILTER_NONE)
+ {
+ png_bytep rp;
+ png_uint_32 sum = 0;
+@@ -2583,7 +2487,7 @@
+ best_row = png_ptr->sub_row;
+ }
+
+- else if (filter_to_do & PNG_FILTER_SUB)
++ else if ((filter_to_do & PNG_FILTER_SUB) != 0)
+ {
+ png_bytep rp, dp, lp;
+ png_uint_32 sum = 0, lmins = mins;
+@@ -2704,7 +2608,7 @@
+ best_row = png_ptr->up_row;
+ }
+
+- else if (filter_to_do & PNG_FILTER_UP)
++ else if ((filter_to_do & PNG_FILTER_UP) != 0)
+ {
+ png_bytep rp, dp, pp;
+ png_uint_32 sum = 0, lmins = mins;
+@@ -2818,7 +2722,7 @@
+ best_row = png_ptr->avg_row;
+ }
+
+- else if (filter_to_do & PNG_FILTER_AVG)
++ else if ((filter_to_do & PNG_FILTER_AVG) != 0)
+ {
+ png_bytep rp, dp, pp, lp;
+ png_uint_32 sum = 0, lmins = mins;
+@@ -2920,7 +2824,7 @@
+ }
+
+ /* Paeth filter */
+- if (filter_to_do == PNG_FILTER_PAETH)
++ if ((filter_to_do == PNG_FILTER_PAETH) != 0)
+ {
+ png_bytep rp, dp, pp, cp, lp;
+ png_size_t i;
+@@ -2959,7 +2863,7 @@
+ best_row = png_ptr->paeth_row;
+ }
+
+- else if (filter_to_do & PNG_FILTER_PAETH)
++ else if ((filter_to_do & PNG_FILTER_PAETH) != 0)
+ {
+ png_bytep rp, dp, pp, cp, lp;
+ png_uint_32 sum = 0, lmins = mins;
+@@ -3029,7 +2933,7 @@
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+ #endif
+ p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
+-#else /* PNG_SLOW_PAETH */
++#else /* SLOW_PAETH */
+ p = a + b - c;
+ pa = abs(p - a);
+ pb = abs(p - b);
+@@ -3043,7 +2947,7 @@
+
+ else
+ p = c;
+-#endif /* PNG_SLOW_PAETH */
++#endif /* SLOW_PAETH */
+
+ v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
+
+@@ -3092,10 +2996,10 @@
+ best_row = png_ptr->paeth_row;
+ }
+ }
+-#endif /* PNG_WRITE_FILTER_SUPPORTED */
++#endif /* WRITE_FILTER */
++
+ /* Do the actual writing of the filtered row data from the chosen filter. */
+-
+- png_write_filtered_row(png_ptr, best_row);
++ png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
+
+ #ifdef PNG_WRITE_FILTER_SUPPORTED
+ #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+@@ -3112,74 +3016,20 @@
+ png_ptr->prev_filters[j] = best_row[0];
+ }
+ #endif
+-#endif /* PNG_WRITE_FILTER_SUPPORTED */
++#endif /* WRITE_FILTER */
+ }
+
+
+ /* Do the actual writing of a previously filtered row. */
+ static void
+-png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
++png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
++ png_size_t full_row_length/*includes filter byte*/)
+ {
+- png_size_t avail;
+-
+ png_debug(1, "in png_write_filtered_row");
+
+ png_debug1(2, "filter = %d", filtered_row[0]);
+- /* Set up the zlib input buffer */
+-
+- png_ptr->zstream.next_in = filtered_row;
+- png_ptr->zstream.avail_in = 0;
+- avail = png_ptr->row_info.rowbytes + 1;
+- /* Repeat until we have compressed all the data */
+- do
+- {
+- int ret; /* Return of zlib */
+-
+- /* Record the number of bytes available - zlib supports at least 65535
+- * bytes at one step, depending on the size of the zlib type 'uInt', the
+- * maximum size zlib can write at once is ZLIB_IO_MAX (from pngpriv.h).
+- * Use this because on 16 bit systems 'rowbytes' can be up to 65536 (i.e.
+- * one more than 16 bits) and, in this case 'rowbytes+1' can overflow a
+- * uInt. ZLIB_IO_MAX can be safely reduced to cause zlib to be called
+- * with smaller chunks of data.
+- */
+- if (png_ptr->zstream.avail_in == 0)
+- {
+- if (avail > ZLIB_IO_MAX)
+- {
+- png_ptr->zstream.avail_in = ZLIB_IO_MAX;
+- avail -= ZLIB_IO_MAX;
+- }
+-
+- else
+- {
+- /* So this will fit in the available uInt space: */
+- png_ptr->zstream.avail_in = (uInt)avail;
+- avail = 0;
+- }
+- }
+-
+- /* Compress the data */
+- ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
+-
+- /* Check for compression errors */
+- if (ret != Z_OK)
+- {
+- if (png_ptr->zstream.msg != NULL)
+- png_error(png_ptr, png_ptr->zstream.msg);
+-
+- else
+- png_error(png_ptr, "zlib error");
+- }
+-
+- /* See if it is time to write another IDAT */
+- if (!(png_ptr->zstream.avail_out))
+- {
+- /* Write the IDAT and reset the zlib output buffer */
+- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
+- }
+- /* Repeat until all data has been compressed */
+- } while (avail > 0 || png_ptr->zstream.avail_in > 0);
++
++ png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH);
+
+ /* Swap the current and previous rows */
+ if (png_ptr->prev_row != NULL)
+@@ -3202,6 +3052,6 @@
+ {
+ png_write_flush(png_ptr);
+ }
+-#endif
++#endif /* WRITE_FLUSH */
+ }
+-#endif /* PNG_WRITE_SUPPORTED */
++#endif /* WRITE */
+--- ./jdk/src/share/native/sun/font/layout/LETableReference.h Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/font/layout/LETableReference.h Thu Feb 05 13:00:26 2015 +0100
+@@ -150,8 +150,8 @@
+ if(isEmpty()) {
+ //err = LE_MISSING_FONT_TABLE_ERROR;
+ clear(); // it's just empty. Not an error.
+- } else if(offset >= fParent->fLength) {
+- LE_DEBUG_TR3("offset out of range: (%p) +%d", NULL, offset);
++ } else if(offset >= fParent->fLength || (offset & 0x01)) {
++ LE_DEBUG_TR3("offset out of range or odd alignment: (%p) +%d", NULL, offset);
+ err = LE_INDEX_OUT_OF_BOUNDS_ERROR;
+ clear();
+ } else {
+--- ./jdk/src/share/native/sun/font/layout/LigatureSubstProc.cpp Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/font/layout/LigatureSubstProc.cpp Thu Feb 05 13:00:26 2015 +0100
+@@ -115,7 +115,7 @@
+ LE_DEBUG_BAD_FONT("off end of ligature substitution header");
+ return newState; // get out! bad font
+ }
+- if(componentGlyph > glyphStorage.getGlyphCount()) {
++ if(componentGlyph >= glyphStorage.getGlyphCount()) {
+ LE_DEBUG_BAD_FONT("preposterous componentGlyph");
+ currGlyph++;
+ return newState; // get out! bad font
+--- ./jdk/src/share/native/sun/font/layout/LigatureSubstProc2.cpp Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/font/layout/LigatureSubstProc2.cpp Thu Feb 05 13:00:26 2015 +0100
+@@ -119,7 +119,7 @@
+
+ offset = action & lafComponentOffsetMask;
+ if (offset != 0) {
+- if(componentGlyph > glyphStorage.getGlyphCount()) {
++ if(componentGlyph >= glyphStorage.getGlyphCount()) {
+ LE_DEBUG_BAD_FONT("preposterous componentGlyph");
+ currGlyph+= dir;
+ return nextStateIndex; // get out! bad font
+--- ./jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/font/layout/LigatureSubstSubtables.cpp Thu Feb 05 13:00:26 2015 +0100
+@@ -58,7 +58,7 @@
+ if( LE_FAILURE(success) ) { return 0; }
+ le_uint16 ligCount = SWAPW(ligSetTable->ligatureCount);
+
+- LEReferenceTo<Offset> ligatureTableOffsetArray(base, success, ligSetTable->ligatureTableOffsetArray, ligCount);
++ LEReferenceToArrayOf<Offset> ligatureTableOffsetArray(base, success, ligSetTable->ligatureTableOffsetArray, ligCount);
+ for (le_uint16 lig = 0; LE_SUCCESS(success) && lig < ligCount; lig += 1) {
+ Offset ligTableOffset = SWAPW(ligSetTable->ligatureTableOffsetArray[lig]);
+ LEReferenceTo<LigatureTable> ligTable(ligSetTable, success, ligTableOffset);
+--- ./jdk/src/share/native/sun/font/layout/LookupProcessor.cpp Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/font/layout/LookupProcessor.cpp Thu Feb 05 13:00:26 2015 +0100
+@@ -255,6 +255,7 @@
+
+ if (requiredFeatureIndex != 0xFFFF) {
+ requiredFeatureTable = featureListTable->getFeatureTable(featureListTable, requiredFeatureIndex, &requiredFeatureTag, success);
++ if (LE_FAILURE(success)) return;
+ featureReferences += SWAPW(requiredFeatureTable->lookupCount);
+ }
+
+@@ -292,7 +293,7 @@
+ }
+
+ featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success);
+-
++ if (LE_FAILURE(success)) continue;
+ if (featureTag == fm.tag) {
+ count += selectLookups(featureTable, fm.mask, order + count, success);
+ }
+@@ -319,7 +320,7 @@
+ #endif
+
+ featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success);
+-
++ if (LE_FAILURE(success)) continue;
+ if (featureTag == fm.tag) {
+ order += selectLookups(featureTable, fm.mask, order, success);
+ }
+--- ./jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/share/native/sun/font/layout/MultipleSubstSubtables.cpp Thu Feb 05 13:00:26 2015 +0100
+@@ -71,7 +71,12 @@
+ if (coverageIndex >= 0 && coverageIndex < seqCount) {
+ Offset sequenceTableOffset = SWAPW(sequenceTableOffsetArray[coverageIndex]);
+ LEReferenceTo<SequenceTable> sequenceTable(base, success, sequenceTableOffset);
++ if (LE_FAILURE(success)) {
++ return 0;
++ }
+ le_uint16 glyphCount = SWAPW(sequenceTable->glyphCount);
++ LEReferenceToArrayOf<Offset>
++ substituteArrayRef(base, success, sequenceTable->substituteArray, glyphCount);
+
+ if (glyphCount == 0) {
+ glyphIterator->setCurrGlyphID(0xFFFF);
+--- ./jdk/src/solaris/native/sun/awt/splashscreen/splashscreen_sys.c Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/src/solaris/native/sun/awt/splashscreen/splashscreen_sys.c Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+@@ -281,9 +281,7 @@
+ /* for changing the visible shape of a window to an nonrectangular form */
+ void
+ SplashUpdateShape(Splash * splash) {
+- if (!shapeSupported)
+- return;
+- if (!splash->maskRequired) {
++ if (splash->currentFrame < 0 || !shapeSupported || !splash->maskRequired) {
+ return;
+ }
+ XShapeCombineRectangles(splash->display, splash->window, ShapeClip, 0, 0,
+@@ -324,6 +322,10 @@
+
+ void
+ SplashRedrawWindow(Splash * splash) {
++ if (splash->currentFrame < 0) {
++ return;
++ }
++
+ XImage *ximage;
+
+ // making this method redraw a part of the image does not make
+--- ./jdk/test/Makefile Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/Makefile Thu Feb 05 13:00:26 2015 +0100
+@@ -262,8 +262,8 @@
+ EXTRA_JTREG_OPTIONS += -concurrency:$(CONCURRENCY)
+ endif
+
+-# Default JTREG to run (win32 script works for everybody)
+-JTREG = $(JT_HOME)/win32/bin/jtreg
++# Default JTREG to run
++JTREG = $(JT_HOME)/bin/jtreg
+ # run in agentvm mode
+ JTREG_BASIC_OPTIONS += -agentvm
+ # Only run automatic tests
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ ./jdk/test/java/awt/Graphics2D/DrawString/DrawRotatedStringUsingRotatedFont.java Thu Feb 05 13:00:26 2015 +0100
+@@ -0,0 +1,162 @@
++/*
++ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
++ * or visit www.oracle.com if you need additional information or have any
++ * questions.
++ */
++
++import java.awt.Color;
++import java.awt.Font;
++import java.awt.Graphics2D;
++import java.awt.RenderingHints;
++import java.awt.geom.AffineTransform;
++import java.awt.image.BufferedImage;
++import java.io.File;
++import java.io.IOException;
++
++import javax.imageio.ImageIO;
++
++import static java.awt.image.BufferedImage.TYPE_INT_RGB;
++import static java.lang.Math.toRadians;
++
++/**
++ * @test
++ * @bug 8065373
++ * @summary Verifies that we get correct direction, when draw rotated string.
++ * @author Sergey Bylokhov
++ * @run main DrawRotatedStringUsingRotatedFont
++ */
++public final class DrawRotatedStringUsingRotatedFont {
++
++ private static final int SIZE = 500;
++ private static final String STR = "MMMMMMMMMMMMMMMM";
++
++ private static AffineTransform[] txs = {
++ AffineTransform.getRotateInstance(toRadians(00)),
++ AffineTransform.getRotateInstance(toRadians(45)),
++ AffineTransform.getRotateInstance(toRadians(-45)),
++ AffineTransform.getRotateInstance(toRadians(90)),
++ AffineTransform.getRotateInstance(toRadians(-90)),
++ AffineTransform.getRotateInstance(toRadians(135)),
++ AffineTransform.getRotateInstance(toRadians(-135)),
++ AffineTransform.getRotateInstance(toRadians(180)),
++ AffineTransform.getRotateInstance(toRadians(-180)),
++ AffineTransform.getRotateInstance(toRadians(225)),
++ AffineTransform.getRotateInstance(toRadians(-225)),
++ AffineTransform.getRotateInstance(toRadians(270)),
++ AffineTransform.getRotateInstance(toRadians(-270)),
++ AffineTransform.getRotateInstance(toRadians(315)),
++ AffineTransform.getRotateInstance(toRadians(-315)),
++ AffineTransform.getRotateInstance(toRadians(360)),
++ AffineTransform.getRotateInstance(toRadians(-360))
++ };
++
++ public static void main(final String[] args) throws IOException {
++ for (final AffineTransform tx2 : txs) {
++ for (final AffineTransform tx1 : txs) {
++ for (final boolean aa : new boolean[]{true, false}) {
++ final BufferedImage bi1 = createImage(aa, tx1, tx2);
++ final BufferedImage bi2 = createImage(aa, tx2, tx1);
++ compareImage(bi1, bi2);
++ fillTextArea(bi1, tx1, tx2);
++ fillTextArea(bi2, tx2, tx1);
++ checkColors(bi1, bi2);
++ }
++ }
++ }
++ System.out.println("Passed");
++ }
++
++ /**
++ * Compares two images.
++ */
++ private static void compareImage(final BufferedImage bi1,
++ final BufferedImage bi2)
++ throws IOException {
++ for (int i = 0; i < SIZE; ++i) {
++ for (int j = 0; j < SIZE; ++j) {
++ if (bi1.getRGB(i, j) != bi2.getRGB(i, j)) {
++ ImageIO.write(bi1, "png", new File("image1.png"));
++ ImageIO.write(bi2, "png", new File("image2.png"));
++ throw new RuntimeException("Failed: wrong text location");
++ }
++ }
++ }
++ }
++
++ /**
++ * Checks an image color. RED and GREEN are allowed only.
++ */
++ private static void checkColors(final BufferedImage bi1,
++ final BufferedImage bi2)
++ throws IOException {
++ for (int i = 0; i < SIZE; ++i) {
++ for (int j = 0; j < SIZE; ++j) {
++ final int rgb1 = bi1.getRGB(i, j);
++ final int rgb2 = bi2.getRGB(i, j);
++ if (rgb1 != rgb2 || rgb1 != 0xFFFF0000 && rgb1 != 0xFF00FF00) {
++ ImageIO.write(bi1, "png", new File("image1.png"));
++ ImageIO.write(bi2, "png", new File("image2.png"));
++ throw new RuntimeException("Failed: wrong text location");
++ }
++ }
++ }
++ }
++
++ /**
++ * Creates an BufferedImage and draws a text, using two transformations,
++ * one for graphics and one for font.
++ */
++ private static BufferedImage createImage(final boolean aa,
++ final AffineTransform gtx,
++ final AffineTransform ftx) {
++ final BufferedImage bi = new BufferedImage(SIZE, SIZE, TYPE_INT_RGB);
++ final Graphics2D bg = bi.createGraphics();
++ bg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
++ aa ? RenderingHints.VALUE_ANTIALIAS_ON
++ : RenderingHints.VALUE_ANTIALIAS_OFF);
++ bg.setColor(Color.RED);
++ bg.fillRect(0, 0, SIZE, SIZE);
++ bg.translate(100, 100);
++ bg.transform(gtx);
++ bg.setColor(Color.BLACK);
++ bg.setFont(bg.getFont().deriveFont(20.0f).deriveFont(ftx));
++ bg.drawString(STR, 0, 0);
++ bg.dispose();
++ return bi;
++ }
++
++ /**
++ * Fills the area of text using green solid color.
++ */
++ private static void fillTextArea(final BufferedImage bi,
++ final AffineTransform tx1,
++ final AffineTransform tx2) {
++ final Graphics2D bg = bi.createGraphics();
++ bg.translate(100, 100);
++ bg.transform(tx1);
++ bg.transform(tx2);
++ bg.setColor(Color.GREEN);
++ final Font font = bg.getFont().deriveFont(20.0f);
++ bg.setFont(font);
++ bg.fill(font.getStringBounds(STR, bg.getFontRenderContext()));
++ bg.dispose();
++ }
++}
++
+--- ./jdk/test/java/awt/SplashScreen/MultiResolutionSplash/MultiResolutionSplashTest.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/java/awt/SplashScreen/MultiResolutionSplash/MultiResolutionSplashTest.java Thu Feb 05 13:00:26 2015 +0100
+@@ -36,7 +36,7 @@
+ import sun.java2d.SunGraphics2D;
+
+ /**
+- * @test
++ * test
+ * @bug 8043869
+ * @author Alexander Scherbatiy
+ * @summary [macosx] java -splash does not honor 2x hi dpi notation for retina
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ ./jdk/test/java/net/Socks/BadProxySelector.java Thu Feb 05 13:00:26 2015 +0100
+@@ -0,0 +1,85 @@
++/*
++ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
++ * or visit www.oracle.com if you need additional information or have any
++ * questions.
++ */
++
++/*
++ * @test
++ * @bug 7178362
++ * @run main/othervm BadProxySelector
++ */
++
++import java.net.InetSocketAddress;
++import java.net.Proxy;
++import java.net.ProxySelector;
++import java.net.Socket;
++import java.net.SocketAddress;
++import java.net.ServerSocket;
++import java.net.URI;
++import java.util.ArrayList;
++import java.util.List;
++import java.io.*;
++
++public class BadProxySelector {
++ public static void main(String[] args) throws Exception {
++ ProxySelector.setDefault(new HTTPProxySelector());
++ try (ServerSocket ss = new ServerSocket(0);
++ Socket s1 = new Socket(ss.getInetAddress(), ss.getLocalPort());
++ Socket s2 = ss.accept()) {
++ }
++
++ ProxySelector.setDefault(new NullHTTPProxySelector());
++ try (ServerSocket ss = new ServerSocket(0);
++ Socket s1 = new Socket(ss.getInetAddress(), ss.getLocalPort());
++ Socket s2 = ss.accept()) {
++ }
++ }
++
++ // always returns bogus HTTP proxies
++ private static class HTTPProxySelector extends ProxySelector {
++ @Override
++ public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {}
++
++ @Override
++ public List<Proxy> select(URI uri) {
++ List<Proxy> proxies = new ArrayList<>();
++ proxies.add(new Proxy(Proxy.Type.HTTP,
++ new InetSocketAddress("localhost", 0)));
++ proxies.add(new Proxy(Proxy.Type.HTTP,
++ new InetSocketAddress("localhost", 0)));
++ return proxies;
++ }
++ }
++
++ private static class NullHTTPProxySelector extends ProxySelector {
++ @Override
++ public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {}
++
++ @Override
++ public List<Proxy> select(URI uri) {
++ List<Proxy> proxies = new ArrayList<>();
++ proxies.add(null);
++ proxies.add(new Proxy(Proxy.Type.HTTP,
++ new InetSocketAddress("localhost", 0)));
++ return proxies;
++ }
++ }
++}
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ ./jdk/test/javax/xml/jaxp/transform/8062923/XslSubstringTest.java Thu Feb 05 13:00:26 2015 +0100
+@@ -0,0 +1,104 @@
++/*
++ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
++ * or visit www.oracle.com if you need additional information or have any
++ * questions.
++ */
++
++/**
++ * @test
++ * @bug 8062923 8062924
++ * @run testng XslSubstringTest
++ * @summary Test xsl substring function with negative, Inf and
++ * NaN length and few other use cases
++ */
++
++import java.io.StringReader;
++import java.io.StringWriter;
++import javax.xml.transform.Source;
++import javax.xml.transform.Templates;
++import javax.xml.transform.Transformer;
++import javax.xml.transform.TransformerFactory;
++import javax.xml.transform.stream.StreamResult;
++import javax.xml.transform.stream.StreamSource;
++
++import static org.testng.Assert.assertEquals;
++import org.testng.annotations.Test;
++
++public class XslSubstringTest {
++
++ final String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><test></test>";
++ final String xslPre = "<xsl:stylesheet version='1.0'"
++ + " xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>"
++ + "<xsl:output method='xml' indent='yes' omit-xml-declaration='yes'/>"
++ + "<xsl:template match='/'><t>";
++ final String xslPost = "</t></xsl:template></xsl:stylesheet>";
++
++ private String testTransform(String xsl) throws Exception {
++ //Prepare sources for transormation
++ Source src = new StreamSource(new StringReader(xml));
++ Source xslsrc = new StreamSource(new StringReader(xslPre + xsl + xslPost));
++ //Create factory, template and transformer
++ TransformerFactory tf = TransformerFactory.newInstance();
++ Templates tmpl = tf.newTemplates(xslsrc);
++ Transformer t = tmpl.newTransformer();
++ //Prepare output stream
++ StringWriter xmlResultString = new StringWriter();
++ StreamResult xmlResultStream = new StreamResult(xmlResultString);
++ //Transform
++ t.transform(src, xmlResultStream);
++ return xmlResultString.toString().trim();
++ }
++
++ @Test
++ public void test8062923() throws Exception {
++ assertEquals(testTransform("|<xsl:value-of select=\"substring('asdf',2,-1)\"/>|"),
++ "<t>||</t>");
++ }
++
++ @Test
++ public void test8062924() throws Exception {
++ assertEquals(testTransform("|<xsl:value-of select=\"substring('asdf',2,-1 div 0)\"/>|"),
++ "<t>||</t>");
++ }
++
++ @Test
++ public void testGeneral1() throws Exception {
++ assertEquals(testTransform("|<xsl:value-of select=\"substring('asdf',2, 1)\"/>|"),
++ "<t>|s|</t>");
++ }
++
++ @Test
++ public void testGeneral2() throws Exception {
++ assertEquals(testTransform("|<xsl:value-of select=\"substring('asdf',2, 1 div 0)\"/>|"),
++ "<t>|sdf|</t>");
++ }
++
++ @Test
++ public void testGeneral3() throws Exception {
++ assertEquals(testTransform("|<xsl:value-of select=\"substring('asdf',2, -0 div 0)\"/>|"),
++ "<t>||</t>");
++ }
++
++ @Test
++ public void testGeneral4() throws Exception {
++ assertEquals(testTransform("|<xsl:value-of select=\"substring('asdf',2, 0 div 0)\"/>|"),
++ "<t>||</t>");
++ }
++}
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ ./jdk/test/javax/xml/ws/8046817/GenerateEnumSchema.java Thu Feb 05 13:00:26 2015 +0100
+@@ -0,0 +1,134 @@
++/*
++ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
++ * or visit www.oracle.com if you need additional information or have any
++ * questions.
++ */
++
++/*
++ * @test
++ * @bug 8046817
++ * @summary schemagen fails to generate xsd for enum types
++ * @run main/othervm GenerateEnumSchema
++ */
++import java.io.BufferedReader;
++import java.io.File;
++import java.io.FileNotFoundException;
++import java.io.IOException;
++import java.io.InputStreamReader;
++import java.nio.file.Paths;
++import java.util.Scanner;
++
++public class GenerateEnumSchema {
++
++ private static final String SCHEMA_OUTPUT_FILENAME = "schema1.xsd";
++ private static final File schemaOutputFile = new File(SCHEMA_OUTPUT_FILENAME);
++
++ public static void main(String[] args) throws Exception, IOException {
++ //Check schema generation for class type
++ runSchemaGen("TestClassType.java");
++ checkIfSchemaGenerated();
++ checkSchemaContent("<xs:complexType name=\"testClassType\">");
++ checkSchemaContent("<xs:element name=\"a\" type=\"xs:int\"/>");
++ schemaOutputFile.delete();
++ //Check schema generation for enum type
++ runSchemaGen("TestEnumType.java");
++ checkIfSchemaGenerated();
++ checkSchemaContent("<xs:simpleType name=\"testEnumType\">");
++ checkSchemaContent("<xs:enumeration value=\"ONE\"/>");
++ checkSchemaContent("<xs:enumeration value=\"TWO\"/>");
++ checkSchemaContent("<xs:enumeration value=\"THREE\"/>");
++ schemaOutputFile.delete();
++ }
++
++ private static void checkIfSchemaGenerated() {
++ if (!schemaOutputFile.exists()) {
++ throw new RuntimeException("FAIL:" + SCHEMA_OUTPUT_FILENAME + " was not generated by schemagen tool");
++ }
++ }
++
++ private static void checkSchemaContent(String exp_token) throws FileNotFoundException {
++ System.out.print("Check if generated schema contains '" + exp_token + "' string: ");
++ try (Scanner scanner = new Scanner(schemaOutputFile)) {
++ if (scanner.findWithinHorizon(exp_token, 0) != null) {
++ System.out.println("OK");
++ return;
++ }
++ }
++ System.out.println("FAIL");
++ throw new RuntimeException("The '" + exp_token + "' is not found in generated schema");
++
++ }
++
++ private static String getClassFilePath(String filename) {
++ String testSrc = System.getProperty("test.src");
++ if (testSrc == null) {
++ testSrc = ".";
++ }
++ return Paths.get(testSrc).resolve(filename).toString();
++ }
++
++ private static String getSchemagen() {
++ String javaHome = System.getProperty("java.home");
++ if (javaHome.endsWith("jre")) {
++ javaHome = new File(javaHome).getParent();
++ }
++ String schemagen = javaHome + File.separator + "bin" + File.separator + "schemagen";
++ if (System.getProperty("os.name").startsWith("Windows")) {
++ schemagen = schemagen.concat(".exe");
++ }
++ return schemagen;
++ }
++
++ private static void logOutput(Process p) throws IOException {
++ BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
++ String s = r.readLine();
++ while (s != null) {
++ System.out.println(s.trim());
++ s = r.readLine();
++ }
++ }
++
++ private static void runSchemaGen(String classFile) {
++ String schemagen = getSchemagen();
++
++ try {
++ System.out.println("Call to schemagen: " + schemagen + " " + classFile);
++ String[] schemagen_args = {
++ schemagen,
++ getClassFilePath(classFile)
++ };
++
++ ProcessBuilder pb = new ProcessBuilder(schemagen_args);
++ pb.redirectErrorStream(true);
++ Process p = pb.start();
++ logOutput(p);
++ int result = p.waitFor();
++ p.destroy();
++
++ if (result != 0) {
++ throw new RuntimeException("schemagen failed");
++ }
++ } catch (IOException | InterruptedException e) {
++ System.err.println("Can't run schemagen tool. Exception:");
++ e.printStackTrace(System.err);
++ throw new RuntimeException("Error launching schemagen tool");
++ }
++ }
++}
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ ./jdk/test/javax/xml/ws/8046817/TestClassType.java Thu Feb 05 13:00:26 2015 +0100
+@@ -0,0 +1,29 @@
++/*
++ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
++ * or visit www.oracle.com if you need additional information or have any
++ * questions.
++ */
++
++import javax.xml.bind.annotation.XmlType;
++
++@XmlType
++public class TestClassType {
++ public int a;
++}
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ ./jdk/test/javax/xml/ws/8046817/TestEnumType.java Thu Feb 05 13:00:26 2015 +0100
+@@ -0,0 +1,29 @@
++/*
++ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
++ * or visit www.oracle.com if you need additional information or have any
++ * questions.
++ */
++
++import javax.xml.bind.annotation.XmlEnum;
++
++@XmlEnum(String.class)
++public enum TestEnumType {
++ ONE, TWO, THREE
++}
+--- ./jdk/test/sun/security/krb5/ParseConfig.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/security/krb5/ParseConfig.java Thu Feb 05 13:00:26 2015 +0100
+@@ -22,7 +22,7 @@
+ */
+ /*
+ * @test
+- * @bug 6319046
++ * @bug 6319046 8055045
+ * @compile -XDignore.symbol.file ParseConfig.java
+ * @run main/othervm ParseConfig
+ * @summary Problem with parsing krb5.conf
+@@ -32,7 +32,8 @@
+
+ public class ParseConfig {
+ public static void main(String[] args) throws Exception {
+- System.setProperty("java.security.krb5.conf", System.getProperty("test.src", ".") +"/krb5.conf");
++ System.setProperty("java.security.krb5.conf",
++ System.getProperty("test.src", ".") + "/krb5.conf");
+ Config config = Config.getInstance();
+ config.listTable();
+
+@@ -44,5 +45,11 @@
+ expected + "\"");
+ }
+ }
++
++ // JDK-8055045: IOOBE when reading an empty value
++ config.get("empty1", "NOVAL.COM");
++ config.get("empty2", "NOVAL.COM");
++ config.get("quote1", "NOVAL.COM");
++ config.get("quote2", "NOVAL.COM");
+ }
+ }
+--- ./jdk/test/sun/security/krb5/krb5.conf Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/security/krb5/krb5.conf Thu Feb 05 13:00:26 2015 +0100
+@@ -27,3 +27,9 @@
+ }
+ }
+
++ NOVAL.COM = {
++ empty1 =
++ empty2 =.
++ quote1 = "
++ quote2 = '
++ }
+--- ./jdk/test/sun/security/tools/keytool/ListKeychainStore.sh Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/security/tools/keytool/ListKeychainStore.sh Thu Feb 05 13:00:26 2015 +0100
+@@ -1,5 +1,5 @@
+ #
+-# Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
++# Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+ # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ #
+ # This code is free software; you can redistribute it and/or modify it
+@@ -22,7 +22,7 @@
+ #
+
+ # @test
+-# @bug 7133495
++# @bug 7133495 8041740
+ # @summary [macosx] KeyChain KeyStore implementation retrieves only one private key entry
+
+ if [ "${TESTJAVA}" = "" ] ; then
+@@ -49,8 +49,10 @@
+ KEYTOOL="${TESTJAVA}/bin/keytool -storetype KeychainStore -keystore NONE -storepass $PWD"
+ TEMPORARY_P12="$TESTCLASSES/7133495.p12"
+ TEMPORARY_KC="$TESTCLASSES/7133495.keychain"
++TEMPORARY_LIST="$TESTCLASSES/7133495.tmp"
+ CLEANUP_P12="rm -f $TEMPORARY_P12"
+ CLEANUP_KC="security delete-keychain $TEMPORARY_KC"
++CLEANUP_LIST="rm -f $TEMPORARY_LIST"
+
+ # Count the number of private key entries in the Keychain keystores
+
+@@ -115,6 +117,15 @@
+ fi
+ echo "Imported keypairs from PKCS12 keystore into the keychain"
+
++# Adjust the keychain search order
++
++echo "\"$TEMPORARY_KC\"" > $TEMPORARY_LIST
++security list-keychains >> $TEMPORARY_LIST
++security list-keychains -s `xargs < ${TEMPORARY_LIST}`
++`$CLEANUP_LIST`
++echo "Temporary keychain search order:"
++security list-keychains
++
+ # Recount the number of private key entries in the Keychain keystores
+
+ COUNT=`$KEYTOOL -list | grep PrivateKeyEntry | wc -l`
+--- ./jdk/test/sun/security/util/HostnameMatcher/TestHostnameChecker.java Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/security/util/HostnameMatcher/TestHostnameChecker.java Thu Feb 05 13:00:26 2015 +0100
+@@ -187,6 +187,9 @@
+ in = new FileInputStream(new File(PATH, "cert4.crt"));
+ X509Certificate cert4 = (X509Certificate)cf.generateCertificate(in);
+ in.close();
++ in = new FileInputStream(new File(PATH, "cert5.crt"));
++ X509Certificate cert5 = (X509Certificate)cf.generateCertificate(in);
++ in.close();
+
+ HostnameChecker checker = HostnameChecker.getInstance(
+ HostnameChecker.TYPE_TLS);
+@@ -202,6 +205,9 @@
+ check(checker, "5.6.7.8", cert3, true);
+ check(checker, "foo.bar.com", cert4, true);
+ check(checker, "altfoo.bar.com", cert4, true);
++ check(checker, "2001:db8:3c4d:15::1a2f:1a2b", cert5, true);
++ check(checker, "2001:0db8:3c4d:0015:0000:0000:1a2f:1a2b", cert5, true);
++ check(checker, "2002:db8:3c4d:15::1a2f:1a2b", cert5, false);
+
+ checker = HostnameChecker.getInstance(
+ HostnameChecker.TYPE_LDAP);
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ ./jdk/test/sun/security/util/HostnameMatcher/cert5.crt Thu Feb 05 13:00:26 2015 +0100
+@@ -0,0 +1,24 @@
++-----BEGIN CERTIFICATE-----
++MIIECDCCAvCgAwIBAgIJAJaBmuUlfY8sMA0GCSqGSIb3DQEBBQUAMIGmMQswCQYD
++VQQGEwJVUzETMBEGA1UECAwKU29tZS1TdGF0ZTESMBAGA1UEBwwJU29tZS1DaXR5
++MSowKAYDVQQKDCFVbmNvbmZpZ3VyZWQgT3BlblNTTCBJbnN0YWxsYXRpb24xEDAO
++BgNVBAsMB3NlY3Rpb24xMDAuBgNVBAMMJzIwMDE6MGRiODozYzRkOjAwMTU6MDAw
++MDowMDAwOjFhMmY6MWEyYjAeFw0xNTAyMTAxODMzMjBaFw0xNTAzMTIxODMzMjBa
++MIGmMQswCQYDVQQGEwJVUzETMBEGA1UECAwKU29tZS1TdGF0ZTESMBAGA1UEBwwJ
++U29tZS1DaXR5MSowKAYDVQQKDCFVbmNvbmZpZ3VyZWQgT3BlblNTTCBJbnN0YWxs
++YXRpb24xEDAOBgNVBAsMB3NlY3Rpb24xMDAuBgNVBAMMJzIwMDE6MGRiODozYzRk
++OjAwMTU6MDAwMDowMDAwOjFhMmY6MWEyYjCCASIwDQYJKoZIhvcNAQEBBQADggEP
++ADCCAQoCggEBAMcigWxmeF6Dmo3xAw3y/8d3vB8Th4YsmvwXb9DxwNWV+B3vxJgq
++ww6T6VBxrle1bgu/RtZDJwLf5vMhVElxuuE86di2qyurKFbpe29C9xnCxuMlXpje
++X2pNknz4ZzOqD4opmIAFjXZ2Xp1kLt+HJX7ABoz7Uga+IbVfDRPPf2KOqYNpBQkp
++dgI5VOZDQNVNb+8vdXDwyanMQ0TgPXKL4BQIkGB4RM8sgpPMUvB+tEB7zmUtgSco
++2a5M84wIhxv85CmFFoTVSzXsRCDhVAZj0aHRkkmAsMSmzPa4HiPnuVRV740oQjDy
++oMGLndaEs2nxIqckUFHOHcSTf0/wmcvPbIsCAwEAAaM3MDUwCQYDVR0TBAIwADAL
++BgNVHQ8EBAMCBeAwGwYDVR0RBBQwEocQIAENuDxNABUAAAAAGi8aKzANBgkqhkiG
++9w0BAQUFAAOCAQEAtnelRbYPPZRgTd4oxOiPqwc01EE9JgtkFWlooCwVUDChOR2k
++us1qlhKsvbN2Tcsm1Ss3p0Uxk/g1o2/mY8rA/dJ8qiN6jbfjpEi8b2MirP5tQSE0
++QNXbVGr5FnLbuUmn+82pB0vBSaq7gxehbV6S7dteyQUnb2imltC5wS9PwYb8wWx7
++IpyXWt0jkYkC8KJEevVYI7qtwpjYhyc1FqwzUiPmdqGz2AFLQ4RgTXJi93SPoyKM
++s65oPV+r6/0qwnslScxVfszHxxFn1Yfsc5Oseare1MnlNzH69PmWs523C/fBvnB2
++MsHKLPdoN7uSpBLB7j46g5jQG/ceri/cquZKYA==
++-----END CERTIFICATE-----
+--- ./jdk/test/sun/util/calendar/zi/tzdata/VERSION Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/VERSION Thu Feb 05 13:00:26 2015 +0100
+@@ -21,4 +21,4 @@
+ # or visit www.oracle.com if you need additional information or have any
+ # questions.
+ #
+-tzdata2014j
++tzdata2015a
+--- ./jdk/test/sun/util/calendar/zi/tzdata/antarctica Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/antarctica Thu Feb 05 13:00:26 2015 +0100
+@@ -70,8 +70,8 @@
+ Rule ChileAQ 2010 only - Apr Sun>=1 3:00u 0 -
+ Rule ChileAQ 2011 only - May Sun>=2 3:00u 0 -
+ Rule ChileAQ 2011 only - Aug Sun>=16 4:00u 1:00 S
+-Rule ChileAQ 2012 max - Apr Sun>=23 3:00u 0 -
+-Rule ChileAQ 2012 max - Sep Sun>=2 4:00u 1:00 S
++Rule ChileAQ 2012 2015 - Apr Sun>=23 3:00u 0 -
++Rule ChileAQ 2012 2014 - Sep Sun>=2 4:00u 1:00 S
+
+ # Argentina - year-round bases
+ # Belgrano II, Confin Coast, -770227-0343737, since 1972-02-05
+@@ -377,9 +377,10 @@
+ #
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+ Zone Antarctica/Palmer 0 - zzz 1965
+- -4:00 ArgAQ AR%sT 1969 Oct 5
++ -4:00 ArgAQ AR%sT 1969 Oct 5
+ -3:00 ArgAQ AR%sT 1982 May
+- -4:00 ChileAQ CL%sT
++ -4:00 ChileAQ CL%sT 2015 Apr 26 3:00u
++ -3:00 - CLT
+ #
+ #
+ # McMurdo Station, Ross Island, since 1955-12
+--- ./jdk/test/sun/util/calendar/zi/tzdata/asia Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/asia Thu Feb 05 13:00:26 2015 +0100
+@@ -168,10 +168,7 @@
+ 4:00 Azer AZ%sT
+
+ # Bahrain
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Bahrain 3:22:20 - LMT 1920 # Manamah
+- 4:00 - GST 1972 Jun
+- 3:00 - AST
++# See Asia/Qatar.
+
+ # Bangladesh
+ # From Alexander Krivenyshev (2009-05-13):
+@@ -1754,9 +1751,7 @@
+ ###############################################################################
+
+ # Kuwait
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Kuwait 3:11:56 - LMT 1950
+- 3:00 - AST
++# See Asia/Riyadh.
+
+ # Laos
+ # See Asia/Bangkok.
+@@ -1977,12 +1972,7 @@
+ 5:45 - NPT # Nepal Time
+
+ # Oman
+-
+-# Milne says 3:54:24 was the meridian of the Muscat Tidal Observatory.
+-
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Muscat 3:54:24 - LMT 1920
+- 4:00 - GST
++# See Asia/Dubai.
+
+ # Pakistan
+
+@@ -2476,6 +2466,7 @@
+ Zone Asia/Qatar 3:26:08 - LMT 1920 # Al Dawhah / Doha
+ 4:00 - GST 1972 Jun
+ 3:00 - AST
++Link Asia/Qatar Asia/Bahrain
+
+ # Saudi Arabia
+ #
+@@ -2502,6 +2493,8 @@
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+ Zone Asia/Riyadh 3:06:52 - LMT 1947 Mar 14
+ 3:00 - AST
++Link Asia/Riyadh Asia/Aden # Yemen
++Link Asia/Riyadh Asia/Kuwait
+
+ # Singapore
+ # taken from Mok Ly Yng (2003-10-30)
+@@ -2790,6 +2783,7 @@
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+ Zone Asia/Dubai 3:41:12 - LMT 1920
+ 4:00 - GST
++Link Asia/Dubai Asia/Muscat # Oman
+
+ # Uzbekistan
+ # Byalokoz 1919 says Uzbekistan was 4:27:53.
+@@ -2874,10 +2868,4 @@
+ 7:00 - ICT
+
+ # Yemen
+-
+-# Milne says 2:59:54 was the meridian of the saluting battery at Aden,
+-# and that Yemen was at 1:55:56, the meridian of the Hagia Sophia.
+-
+-# Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Asia/Aden 2:59:54 - LMT 1950
+- 3:00 - AST
++# See Asia/Riyadh.
+--- ./jdk/test/sun/util/calendar/zi/tzdata/backward Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/backward Thu Feb 05 13:00:26 2015 +0100
+@@ -28,7 +28,7 @@
+ # and their old names. Many names changed in late 1993.
+
+ # Link TARGET LINK-NAME
+-Link Africa/Asmara Africa/Asmera
++Link Africa/Nairobi Africa/Asmera
+ Link Africa/Abidjan Africa/Timbuktu
+ Link America/Argentina/Catamarca America/Argentina/ComodRivadavia
+ Link America/Adak America/Atka
+--- ./jdk/test/sun/util/calendar/zi/tzdata/europe Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/europe Thu Feb 05 13:00:26 2015 +0100
+@@ -1430,35 +1430,32 @@
+ # might be a reference to the Julian calendar as opposed to Gregorian, or it
+ # might mean something else (???).
+ #
+-# From Paul Eggert (2006-03-22):
+-# The Iceland Almanak, Shanks & Pottenger, and Whitman disagree on many points.
+-# We go with the Almanak, except for one claim from Shanks & Pottenger, namely
+-# that Reykavik was 21W57 from 1837 to 1908, local mean time before that.
++# From Paul Eggert (2014-11-22):
++# The information below is taken from the 1988 Almanak; see
++# http://www.almanak.hi.is/klukkan.html
+ #
+ # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S
+-Rule Iceland 1917 1918 - Feb 19 23:00 1:00 S
++Rule Iceland 1917 1919 - Feb 19 23:00 1:00 S
+ Rule Iceland 1917 only - Oct 21 1:00 0 -
+-Rule Iceland 1918 only - Nov 16 1:00 0 -
++Rule Iceland 1918 1919 - Nov 16 1:00 0 -
++Rule Iceland 1921 only - Mar 19 23:00 1:00 S
++Rule Iceland 1921 only - Jun 23 1:00 0 -
+ Rule Iceland 1939 only - Apr 29 23:00 1:00 S
+-Rule Iceland 1939 only - Nov 29 2:00 0 -
++Rule Iceland 1939 only - Oct 29 2:00 0 -
+ Rule Iceland 1940 only - Feb 25 2:00 1:00 S
+-Rule Iceland 1940 only - Nov 3 2:00 0 -
+-Rule Iceland 1941 only - Mar 2 1:00s 1:00 S
+-Rule Iceland 1941 only - Nov 2 1:00s 0 -
+-Rule Iceland 1942 only - Mar 8 1:00s 1:00 S
+-Rule Iceland 1942 only - Oct 25 1:00s 0 -
++Rule Iceland 1940 1941 - Nov Sun>=2 1:00s 0 -
++Rule Iceland 1941 1942 - Mar Sun>=2 1:00s 1:00 S
+ # 1943-1946 - first Sunday in March until first Sunday in winter
+ Rule Iceland 1943 1946 - Mar Sun>=1 1:00s 1:00 S
+-Rule Iceland 1943 1948 - Oct Sun>=22 1:00s 0 -
++Rule Iceland 1942 1948 - Oct Sun>=22 1:00s 0 -
+ # 1947-1967 - first Sunday in April until first Sunday in winter
+ Rule Iceland 1947 1967 - Apr Sun>=1 1:00s 1:00 S
+-# 1949 Oct transition delayed by 1 week
++# 1949 and 1967 Oct transitions delayed by 1 week
+ Rule Iceland 1949 only - Oct 30 1:00s 0 -
+ Rule Iceland 1950 1966 - Oct Sun>=22 1:00s 0 -
+ Rule Iceland 1967 only - Oct 29 1:00s 0 -
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+-Zone Atlantic/Reykjavik -1:27:24 - LMT 1837
+- -1:27:48 - RMT 1908 # Reykjavik Mean Time?
++Zone Atlantic/Reykjavik -1:28 - LMT 1908
+ -1:00 Iceland IS%sT 1968 Apr 7 1:00s
+ 0:00 - GMT
+
+--- ./jdk/test/sun/util/calendar/zi/tzdata/leapseconds Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/leapseconds Thu Feb 05 13:00:26 2015 +0100
+@@ -77,3 +77,7 @@
+ Leap 2005 Dec 31 23:59:60 + S
+ Leap 2008 Dec 31 23:59:60 + S
+ Leap 2012 Jun 30 23:59:60 + S
++Leap 2015 Jun 30 23:59:60 + S
++
++# Updated through IERS Bulletin C49
++# File expires on: 28 December 2015
+--- ./jdk/test/sun/util/calendar/zi/tzdata/northamerica Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/northamerica Thu Feb 05 13:00:26 2015 +0100
+@@ -147,7 +147,7 @@
+ Rule US 1918 1919 - Oct lastSun 2:00 0 S
+ Rule US 1942 only - Feb 9 2:00 1:00 W # War
+ Rule US 1945 only - Aug 14 23:00u 1:00 P # Peace
+-Rule US 1945 only - Sep 30 2:00 0 S
++Rule US 1945 only - Sep lastSun 2:00 0 S
+ Rule US 1967 2006 - Oct lastSun 2:00 0 S
+ Rule US 1967 1973 - Apr lastSun 2:00 1:00 D
+ Rule US 1974 only - Jan 6 2:00 1:00 D
+@@ -2147,11 +2147,11 @@
+
+ # Mexico
+
+-# From Paul Eggert (2001-03-05):
++# From Paul Eggert (2014-12-07):
+ # The Investigation and Analysis Service of the
+ # Mexican Library of Congress (MLoC) has published a
+ # history of Mexican local time (in Spanish)
+-# http://www.cddhcu.gob.mx/bibliot/publica/inveyana/polisoc/horver/
++# http://www.diputados.gob.mx/bibliot/publica/inveyana/polisoc/horver/index.htm
+ #
+ # Here are the discrepancies between Shanks & Pottenger (S&P) and the MLoC.
+ # (In all cases we go with the MLoC.)
+@@ -2320,6 +2320,24 @@
+ # efecto desde las dos horas del segundo domingo de marzo y concluirá a
+ # las dos horas del primer domingo de noviembre.
+
++# From Steffen Thorsen (2014-12-08), translated by Gwillim Law:
++# The Mexican state of Quintana Roo will likely change to EST in 2015.
++#
++# http://www.unioncancun.mx/articulo/2014/12/04/medio-ambiente/congreso-aprueba-una-hora-mas-de-sol-en-qroo
++# "With this change, the time conflict that has existed between the municipios
++# of Quintana Roo and the municipio of Felipe Carrillo Puerto may come to an
++# end. The latter declared itself in rebellion 15 years ago when a time change
++# was initiated in Mexico, and since then it has refused to change its time
++# zone along with the rest of the country."
++#
++# From Steffen Thorsen (2015-01-14), translated by Gwillim Law:
++# http://sipse.com/novedades/confirman-aplicacion-de-nueva-zona-horaria-para-quintana-roo-132331.html
++# "...the new time zone will come into effect at two o'clock on the first Sunday
++# of February, when we will have to advance the clock one hour from its current
++# time..."
++#
++# Also, the new zone will not use DST.
++
+ # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S
+ Rule Mexico 1939 only - Feb 5 0:00 1:00 D
+ Rule Mexico 1939 only - Jun 25 0:00 0 S
+@@ -2340,7 +2358,8 @@
+ Zone America/Cancun -5:47:04 - LMT 1922 Jan 1 0:12:56
+ -6:00 - CST 1981 Dec 23
+ -5:00 Mexico E%sT 1998 Aug 2 2:00
+- -6:00 Mexico C%sT
++ -6:00 Mexico C%sT 2015 Feb 1 2:00
++ -5:00 - EST
+ # Campeche, Yucatán; represented by Mérida
+ Zone America/Merida -5:58:28 - LMT 1922 Jan 1 0:01:32
+ -6:00 - CST 1981 Dec 23
+--- ./jdk/test/sun/util/calendar/zi/tzdata/southamerica Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/southamerica Thu Feb 05 13:00:26 2015 +0100
+@@ -1229,6 +1229,11 @@
+ # DST Start: first Saturday of September 2014 (Sun 07 Sep 2014 04:00 UTC)
+ # http://www.diariooficial.interior.gob.cl//media/2014/02/19/do-20140219.pdf
+
++# From Juan Correa (2015-01-28):
++# ... today the Ministry of Energy announced that Chile will drop DST, will keep
++# "summer time" (UTC -3 / UTC -5) all year round....
++# http://www.minenergia.cl/ministerio/noticias/generales/ministerio-de-energia-anuncia.html
++
+ # NOTE: ChileAQ rules for Antarctic bases are stored separately in the
+ # 'antarctica' file.
+
+@@ -1270,8 +1275,8 @@
+ Rule Chile 2010 only - Apr Sun>=1 3:00u 0 -
+ Rule Chile 2011 only - May Sun>=2 3:00u 0 -
+ Rule Chile 2011 only - Aug Sun>=16 4:00u 1:00 S
+-Rule Chile 2012 max - Apr Sun>=23 3:00u 0 -
+-Rule Chile 2012 max - Sep Sun>=2 4:00u 1:00 S
++Rule Chile 2012 2015 - Apr Sun>=23 3:00u 0 -
++Rule Chile 2012 2014 - Sep Sun>=2 4:00u 1:00 S
+ # IATA SSIM anomalies: (1992-02) says 1992-03-14;
+ # (1996-09) says 1998-03-08. Ignore these.
+ # Zone NAME GMTOFF RULES FORMAT [UNTIL]
+@@ -1282,11 +1287,13 @@
+ -4:00 - CLT 1919 Jul 1 # Chile Time
+ -4:42:46 - SMT 1927 Sep 1 # Santiago Mean Time
+ -5:00 Chile CL%sT 1947 May 22 # Chile Time
+- -4:00 Chile CL%sT
++ -4:00 Chile CL%sT 2015 Apr 26 3:00u
++ -3:00 - CLT
+ Zone Pacific/Easter -7:17:44 - LMT 1890
+ -7:17:28 - EMT 1932 Sep # Easter Mean Time
+- -7:00 Chile EAS%sT 1982 Mar 13 21:00 # Easter Time
+- -6:00 Chile EAS%sT
++ -7:00 Chile EAS%sT 1982 Mar 13 3:00u # Easter Time
++ -6:00 Chile EAS%sT 2015 Apr 26 3:00u
++ -5:00 - EAST
+ #
+ # Salas y Gómez Island is uninhabited.
+ # Other Chilean locations, including Juan Fernández Is, Desventuradas Is,
+--- ./jdk/test/sun/util/calendar/zi/tzdata/zone.tab Mon Feb 02 10:12:21 2015 -0800
++++ ./jdk/test/sun/util/calendar/zi/tzdata/zone.tab Thu Feb 05 13:00:26 2015 +0100
+@@ -297,7 +297,7 @@
+ MV +0410+07330 Indian/Maldives
+ MW -1547+03500 Africa/Blantyre
+ MX +1924-09909 America/Mexico_City Central Time - most locations
+-MX +2105-08646 America/Cancun Central Time - Quintana Roo
++MX +2105-08646 America/Cancun Eastern Standard Time - Quintana Roo
+ MX +2058-08937 America/Merida Central Time - Campeche, Yucatan
+ MX +2540-10019 America/Monterrey Mexican Central Time - Coahuila, Durango, Nuevo Leon, Tamaulipas away from US border
+ MX +2550-09730 America/Matamoros US Central Time - Coahuila, Durango, Nuevo Leon, Tamaulipas near US border
+--- ./langtools/.hgtags Wed Jan 28 12:08:47 2015 -0800
++++ ./langtools/.hgtags Tue Mar 17 11:25:42 2015 -0700
+@@ -334,6 +334,8 @@
+ 53ca196be1ae098466976c017b166d4ce180c36f jdk8u25-b17
+ a4f0c6dd8f97d4dd89baf09463c748abea9b3ed7 jdk8u25-b18
+ c4de614efd7affc001715aa5a7040620924ac44a jdk8u25-b31
++a2a922ccc00f29af625cbecde8e77643c60f147c jdk8u25-b32
++b72a49d88cc3f5394b69b861455552476341558d jdk8u25-b33
+ c4bd223559aad3d152968a09d56241175d82c561 jdk8u31-b00
+ 6b5e2c190f3023162a33b798e57a0d78e027c843 jdk8u31-b01
+ 8b4ea00b438d7f99ecd6a8345cb018d8a0379620 jdk8u31-b02
+@@ -348,6 +350,8 @@
+ e72be544fa9e247fba3c6bb61e291d80e127a461 jdk8u31-b11
+ c956b12b30ee21a4fc5df1871fa3b01e84310ebe jdk8u31-b12
+ 7a34ec7bb1c831e82ac88da578a028572b676260 jdk8u31-b13
++b813a76f10911ac8db2c775e52b29f36ab0005f4 jdk8u31-b31
++8dc0c7e42d90c9f323582b742a7f228bad57b124 jdk8u31-b32
+ d231957fe3103e790465fcf058fb8cb33bbc4c4e jdk8u40-b00
+ bf89a471779d13a9407f7d1c86f7716258bc4aa6 jdk8u40-b01
+ 0b6cc4ea670f5d17b56c088f202869bdbb80a5ce jdk8u40-b02
+@@ -372,3 +376,21 @@
+ 9113c7c8d902ec94b28ca0ef4a6466bdba65fcfc jdk8u40-b21
+ 79177246b3dbe5296fb53755d8695acdaef59fc8 jdk8u40-b22
+ fb294b49373bda0b3afc7f011d64ecefed73b42e jdk8u40-b23
++c5d4ffa220f3824c2ea5d39dc99d41a9df9e5ae5 jdk8u40-b24
++991141080b2078e67179ff307a5051e59431762c jdk8u40-b25
++2904142783dd0a9e12195a84c7dcdb3d8278b1b1 jdk8u40-b26
++83eca922346e27ec42645e9630c04fbaec5eaf0f jdk8u40-b27
++dbae37f50c43453f7d6f22d96adc8b5b6cd1e90d jdk8u45-b00
++244e6dc772877dfae6286530f58e11a210a48a3c jdk8u45-b01
++401ec76887623a29d3f868f9f9b18b42838d2e92 jdk8u45-b02
++79d31ae9990e28b99dd64beda6dd247993138431 jdk8u45-b03
++47292f3c0da7dd197a28765004b588bc3141d189 jdk8u45-b04
++77d7dd7f35d63f9fe60ed0b7ef32e4e9a8b46c0b jdk8u45-b05
++22cc48973eae62c63e68c4c4e3f22ff2d89012a8 jdk8u45-b06
++460238ab73ce27112b3d0d7236366960f9898259 jdk8u45-b07
++6dd7fd9f027bf037517feae2a571848aa8fbc20f jdk8u45-b08
++db16aa5c73c99d0050246660ebebb6166002ff57 jdk8u45-b09
++572895f19937b7aadc8c27c5e83887bf40f5bcff jdk8u45-b10
++0547ef2be3b303923b30ce78e1ab832725483f4e jdk8u45-b11
++4f89bbda7b4532b9f6eeee8c41b7a3b38570ae93 jdk8u45-b12
++5ce022bca792453a7efedaed419a9d763d7a9fc3 jdk8u45-b13
+--- ./langtools/THIRD_PARTY_README Wed Jan 28 12:08:47 2015 -0800
++++ ./langtools/THIRD_PARTY_README Tue Mar 17 11:25:42 2015 -0700
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
+--- ./nashorn/.hgtags Wed Jan 28 12:08:49 2015 -0800
++++ ./nashorn/.hgtags Tue Mar 17 11:25:52 2015 -0700
+@@ -322,6 +322,8 @@
+ 4b9cc65dd24d398c4f921c0beccfb8caeaaaf584 jdk8u25-b17
+ cdbf34dbef404b47805c8c85b11c65c2afaa6674 jdk8u25-b18
+ 4f9e65387c21831d0ea5726641a302c2ce73a4cc jdk8u25-b31
++be20e9a00818df15af12544c21839c3a3d5768d9 jdk8u25-b32
++a8526abf70a8c98aee5fed64eb727210745a6e5a jdk8u25-b33
+ 9b692a6e5f22228f822973d35610d37cb9dd9693 jdk8u31-b00
+ 6bf53bb6c969678488b1c073d56dd55df1a0ea17 jdk8u31-b01
+ 809bf97d7e70dcb3873fcbc10f12f62580b1c11d jdk8u31-b02
+@@ -336,6 +338,8 @@
+ 599bd596fa549d882aa8fc5104c322a75a3af728 jdk8u31-b11
+ f36c71a03e4ed467f630cc46d076a5bb4c58b6d5 jdk8u31-b12
+ ec36fa3b35eb00f053d624ae837579c6b8e446ac jdk8u31-b13
++34a64e22b81bd78cf29603a80ff1f4cfc1694df8 jdk8u31-b31
++d2b5784a3452a4fd9d1ccfefe93ee2d36662842c jdk8u31-b32
+ f2925491b61b22ac42f8c30ee9c6723ffa401a4c jdk8u40-b00
+ 62468d841b842769d875bd97d10370585c296eb7 jdk8u40-b01
+ b476c69c820ac1e05071f4de5abab8e2dff80e87 jdk8u40-b02
+@@ -360,3 +364,21 @@
+ dbb663a9d9aa2807ef501c7d20f29415816a1973 jdk8u40-b21
+ f9f70a0f60f48fbb95275b6c1110cedf740c6177 jdk8u40-b22
+ 6ca090832d30fd0e46214ccc00816490ad75a8ab jdk8u40-b23
++b2ce5df33715583c898530560d4202853b9ff9bc jdk8u40-b24
++fb7b6c2b95c5661f15e8e747a63ec6d95d49fe46 jdk8u40-b25
++b142a2d8e35e54abb08a7ded1dbfb5d7ce534c93 jdk8u40-b26
++c2dd88e89edc85b1bcb731d3296d0fcec1b78447 jdk8u40-b27
++05a3614ed5276e5db2a73cce918be04b1a2922fb jdk8u45-b00
++21ec16eb7e6346c78b4fa67ccd6d2a9c58f0b696 jdk8u45-b01
++37b3ef9a07323afd2556d6837824db154cccc874 jdk8u45-b02
++ed3a4177da50d75d6da55ff521bf3f971cfe5214 jdk8u45-b03
++65f24dedfd29ec02af43f745742647412d90f005 jdk8u45-b04
++de2ee4c1341fd4eeaba39b81194df0c4274e7c8b jdk8u45-b05
++cf0097b8987d2d2f480d8a6d2a8f235509bd4421 jdk8u45-b06
++bb112473c7314146bebb75fb5220b4ec641b0b7a jdk8u45-b07
++8ab14ee47c8b1558854d3cd71006eceb6c6804d1 jdk8u45-b08
++397ea4a1bff8adbceaa1a40ff826b3d2d3b09e81 jdk8u45-b09
++c650c13d2bdf0e869ae86685de6bbb8a4e983ca3 jdk8u45-b10
++6ae873ddbe195aa966fc348e468c0ecd2702f5e3 jdk8u45-b11
++9b9fee0f99cd07fba62abaafe705665a5ab89067 jdk8u45-b12
++6fda38586f73de706ecde311711a587ac49d51d8 jdk8u45-b13
+--- ./nashorn/THIRD_PARTY_README Wed Jan 28 12:08:49 2015 -0800
++++ ./nashorn/THIRD_PARTY_README Tue Mar 17 11:25:52 2015 -0700
+@@ -1250,7 +1250,7 @@
+
+ -------------------------------------------------------------------------------
+
+-%% This notice is provided with respect to libpng 1.5.4, which may be
++%% This notice is provided with respect to libpng 1.6.16, which may be
+ included with JRE 8, JDK 8, and OpenJDK 8.
+
+ --- begin of LICENSE ---
+@@ -1266,8 +1266,8 @@
+
+ This code is released under the libpng license.
+
+-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
++libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
++Copyright (c) 2004, 2006-2014 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
+
+@@ -1364,7 +1364,7 @@
+
+ Glenn Randers-Pehrson
+ glennrp at users.sourceforge.net
+-July 7, 2011
++December 22, 2014
+
+ --- end of LICENSE ---
+
diff --git a/java/openjdk8/files/patch-bsd b/java/openjdk8/files/patch-bsd
index d3c863149677..af135e767947 100644
--- a/java/openjdk8/files/patch-bsd
+++ b/java/openjdk8/files/patch-bsd
@@ -1,12 +1,5 @@
---- ./.hgtags Wed Jan 28 12:08:30 2015 -0800
-+++ ./.hgtags Sat Mar 14 10:28:41 2015 -0700
-@@ -374,3 +374,4 @@
- 765a17e75fd622f7b892381e23c9b2c531d416f0 jdk8u40-b21
- b6d03a810a61116268fea08517a9632bd66a7363 jdk8u40-b22
- 5dd2ad6c7911a1e21f15a28f13ffad662378a3be jdk8u40-b23
-+5b37e6757d7c95c9c58b07fb3c9eba234567385a jdk8u40-b24
---- ./common/autoconf/build-performance.m4 Wed Jan 28 12:08:30 2015 -0800
-+++ ./common/autoconf/build-performance.m4 Sat Mar 14 10:28:41 2015 -0700
+--- ./common/autoconf/build-performance.m4 Mon Mar 16 11:19:14 2015 -0700
++++ ./common/autoconf/build-performance.m4 Tue May 05 18:06:47 2015 -0700
@@ -41,6 +41,10 @@
# Looks like a MacOSX system
NUM_CORES=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Cores' | awk '{print [$]5}'`
@@ -41,8 +34,8 @@
AC_MSG_RESULT([no, disabling ccache])
CCACHE=
else
---- ./common/autoconf/generated-configure.sh Wed Jan 28 12:08:30 2015 -0800
-+++ ./common/autoconf/generated-configure.sh Sat Mar 14 10:28:41 2015 -0700
+--- ./common/autoconf/generated-configure.sh Mon Mar 16 11:19:14 2015 -0700
++++ ./common/autoconf/generated-configure.sh Tue May 05 18:06:47 2015 -0700
@@ -1048,6 +1048,7 @@
with_extra_cflags
with_extra_cxxflags
@@ -241,8 +234,8 @@
elif test "x$OPENJDK_BUILD_OS" = xwindows; then
# Windows, but without cygwin
MEMORY_SIZE=`wmic computersystem get totalphysicalmemory -value | grep = | cut -d "=" -f 2-`
---- ./common/autoconf/libraries.m4 Wed Jan 28 12:08:30 2015 -0800
-+++ ./common/autoconf/libraries.m4 Sat Mar 14 10:28:41 2015 -0700
+--- ./common/autoconf/libraries.m4 Mon Mar 16 11:19:14 2015 -0700
++++ ./common/autoconf/libraries.m4 Tue May 05 18:06:47 2015 -0700
@@ -71,9 +71,9 @@
fi
@@ -297,8 +290,8 @@
+
AC_SUBST(LIBCXX)
])
---- ./common/autoconf/platform.m4 Wed Jan 28 12:08:30 2015 -0800
-+++ ./common/autoconf/platform.m4 Sat Mar 14 10:28:41 2015 -0700
+--- ./common/autoconf/platform.m4 Mon Mar 16 11:19:14 2015 -0700
++++ ./common/autoconf/platform.m4 Tue May 05 18:06:47 2015 -0700
@@ -30,7 +30,7 @@
[
# First argument is the cpu name from the trip/quad
@@ -319,8 +312,8 @@
OPENJDK_TARGET_CPU_OSARCH="i386"
elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
# On all platforms except macosx, we replace x86_64 with amd64.
---- ./common/autoconf/spec.gmk.in Wed Jan 28 12:08:30 2015 -0800
-+++ ./common/autoconf/spec.gmk.in Sat Mar 14 10:28:41 2015 -0700
+--- ./common/autoconf/spec.gmk.in Mon Mar 16 11:19:14 2015 -0700
++++ ./common/autoconf/spec.gmk.in Tue May 05 18:06:47 2015 -0700
@@ -275,7 +275,7 @@
ALSA_LIBS:=@ALSA_LIBS@
ALSA_CFLAGS:=@ALSA_CFLAGS@
@@ -330,8 +323,8 @@
# Source file for cacerts
CACERTS_FILE=@CACERTS_FILE@
---- ./common/autoconf/toolchain.m4 Wed Jan 28 12:08:30 2015 -0800
-+++ ./common/autoconf/toolchain.m4 Sat Mar 14 10:28:41 2015 -0700
+--- ./common/autoconf/toolchain.m4 Mon Mar 16 11:19:14 2015 -0700
++++ ./common/autoconf/toolchain.m4 Tue May 05 18:06:47 2015 -0700
@@ -72,7 +72,7 @@
else
COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
@@ -408,16 +401,16 @@
fi
if test "x$OPENJDK_TARGET_OS" = xlinux; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX"
---- ./configure Wed Jan 28 12:08:30 2015 -0800
-+++ ./configure Sat Mar 14 10:28:41 2015 -0700
+--- ./configure Mon Mar 16 11:19:14 2015 -0700
++++ ./configure Tue May 05 18:06:47 2015 -0700
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
#
# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
---- ./make/Main.gmk Wed Jan 28 12:08:30 2015 -0800
-+++ ./make/Main.gmk Sat Mar 14 10:28:41 2015 -0700
+--- ./make/Main.gmk Mon Mar 16 11:19:14 2015 -0700
++++ ./make/Main.gmk Tue May 05 18:06:47 2015 -0700
@@ -58,7 +58,11 @@
# Setup number of jobs to use. -jN is unfortunately not available for us to parse from the command line,
@@ -430,8 +423,8 @@
### Main targets
---- ./make/common/MakeBase.gmk Wed Jan 28 12:08:30 2015 -0800
-+++ ./make/common/MakeBase.gmk Sat Mar 14 10:28:41 2015 -0700
+--- ./make/common/MakeBase.gmk Mon Mar 16 11:19:14 2015 -0700
++++ ./make/common/MakeBase.gmk Tue May 05 18:06:47 2015 -0700
@@ -338,7 +338,7 @@
# (and causing a crash on Cygwin).
# Default shell seems to always be /bin/sh. Must override with bash to get this to work on Solaris.
@@ -452,8 +445,8 @@
endef
# Make directory without forking mkdir if not needed
---- ./make/common/NativeCompilation.gmk Wed Jan 28 12:08:30 2015 -0800
-+++ ./make/common/NativeCompilation.gmk Sat Mar 14 10:28:41 2015 -0700
+--- ./make/common/NativeCompilation.gmk Mon Mar 16 11:19:14 2015 -0700
++++ ./make/common/NativeCompilation.gmk Tue May 05 18:06:47 2015 -0700
@@ -151,9 +151,9 @@
# CC the compiler to use, default is $(CC)
# LDEXE the linker to use for linking executables, default is $(LDEXE)
@@ -467,22 +460,8 @@
ifneq (,$$($1_BIN))
$$(error BIN has been replaced with OBJECT_DIR)
---- ./corba/.hgtags Wed Jan 28 12:08:31 2015 -0800
-+++ ./corba/.hgtags Wed Feb 04 12:14:39 2015 -0800
-@@ -372,3 +372,4 @@
- 9c54cc92c0beb29179abbce272d3f5c8ba4ffd0e jdk8u40-b21
- 4c7421f74674ebefb8e91eba59ab2a2db8c1abd7 jdk8u40-b22
- 62f7faef5ed956cd481cae6216b22fdb4b6e3e46 jdk8u40-b23
-+472aa5bae0e78614e873d56bcc31e7caba49963c jdk8u40-b24
---- ./hotspot/.hgtags Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/.hgtags Sat Mar 14 16:41:08 2015 -0700
-@@ -586,3 +586,4 @@
- 0f0cb4eeab2d871274f4ffdcd6017d2fdfa89238 hs25.40-b25
- 0ee548a1cda08c884eccd563e2d5fdb6ee769b5a jdk8u40-b22
- 0e67683b700174eab71ea205d1cfa4f1cf4523ba jdk8u40-b23
-+fa4e797f61e6dda1a60e06944018213bff2a1b76 jdk8u40-b24
---- ./hotspot/make/bsd/makefiles/build_vm_def.sh Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/build_vm_def.sh Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/build_vm_def.sh Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/build_vm_def.sh Tue May 05 18:06:56 2015 -0700
@@ -1,12 +1,28 @@
#!/bin/sh
@@ -518,8 +497,8 @@
+ if ($3 ~ /^_ZN9Arguments17SharedArchivePathE$/) print "\t" $3 ";"
+ }' | sort -u ;;
+esac
---- ./hotspot/make/bsd/makefiles/debug.make Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/debug.make Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/debug.make Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/debug.make Tue May 05 18:06:56 2015 -0700
@@ -35,7 +35,10 @@
# to inhibit the effect of the previous line on CFLAGS.
@@ -532,8 +511,8 @@
VERSION = debug
SYSDEFS += -DASSERT
---- ./hotspot/make/bsd/makefiles/fastdebug.make Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/fastdebug.make Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/fastdebug.make Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/fastdebug.make Tue May 05 18:06:56 2015 -0700
@@ -56,7 +56,10 @@
# to inhibit the effect of the previous line on CFLAGS.
@@ -546,8 +525,8 @@
VERSION = fastdebug
SYSDEFS += -DASSERT -DCHECK_UNHANDLED_OOPS
---- ./hotspot/make/bsd/makefiles/gcc.make Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/gcc.make Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/gcc.make Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/gcc.make Tue May 05 18:06:56 2015 -0700
@@ -168,6 +168,9 @@
CFLAGS += -DDONT_USE_PRECOMPILED_HEADER
endif
@@ -590,7 +569,7 @@
WARNING_FLAGS += -Wconversion
endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./hotspot/make/bsd/makefiles/launcher.make Sat Mar 14 16:41:08 2015 -0700
++++ ./hotspot/make/bsd/makefiles/launcher.make Tue May 05 18:06:56 2015 -0700
@@ -0,0 +1,117 @@
+#
+# Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
@@ -709,8 +688,8 @@
+ $(QUIETLY) sed -e 's/@@LIBARCH@@/$(LIBARCH)/g' $< > $@
+ $(QUIETLY) chmod +x $@
+
---- ./hotspot/make/bsd/makefiles/mapfile-vers-debug Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/mapfile-vers-debug Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/mapfile-vers-debug Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/mapfile-vers-debug Tue May 05 18:06:56 2015 -0700
@@ -21,246 +21,254 @@
# questions.
#
@@ -1198,7 +1177,7 @@
+ *;
+};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./hotspot/make/bsd/makefiles/mapfile-vers-debug.macosx Sat Mar 14 16:41:08 2015 -0700
++++ ./hotspot/make/bsd/makefiles/mapfile-vers-debug.macosx Tue May 05 18:06:56 2015 -0700
@@ -0,0 +1,266 @@
+#
+# Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
@@ -1466,8 +1445,8 @@
+
+ # INSERT VTABLE SYMBOLS HERE
+
---- ./hotspot/make/bsd/makefiles/mapfile-vers-product Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/mapfile-vers-product Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/mapfile-vers-product Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/mapfile-vers-product Tue May 05 18:06:56 2015 -0700
@@ -21,241 +21,249 @@
# questions.
#
@@ -1946,7 +1925,7 @@
+ *;
+};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./hotspot/make/bsd/makefiles/mapfile-vers-product.macosx Sat Mar 14 16:41:08 2015 -0700
++++ ./hotspot/make/bsd/makefiles/mapfile-vers-product.macosx Tue May 05 18:06:56 2015 -0700
@@ -0,0 +1,261 @@
+#
+# Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
@@ -2209,8 +2188,8 @@
+
+ # INSERT VTABLE SYMBOLS HERE
+
---- ./hotspot/make/bsd/makefiles/optimized.make Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/optimized.make Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/optimized.make Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/optimized.make Tue May 05 18:06:56 2015 -0700
@@ -38,6 +38,9 @@
# to inhibit the effect of the previous line on CFLAGS.
@@ -2222,8 +2201,8 @@
+MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug$(MAPSUFX)
VERSION = optimized
---- ./hotspot/make/bsd/makefiles/product.make Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/product.make Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/product.make Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/product.make Tue May 05 18:06:56 2015 -0700
@@ -38,7 +38,10 @@
# to inhibit the effect of the previous line on CFLAGS.
@@ -2236,8 +2215,8 @@
SYSDEFS += -DPRODUCT
VERSION = optimized
---- ./hotspot/make/bsd/makefiles/rules.make Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/make/bsd/makefiles/rules.make Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/make/bsd/makefiles/rules.make Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/make/bsd/makefiles/rules.make Tue May 05 18:06:56 2015 -0700
@@ -34,7 +34,7 @@
CC_COMPILE = $(CC) $(CXXFLAGS) $(CFLAGS)
CXX_COMPILE = $(CXX) $(CXXFLAGS) $(CFLAGS)
@@ -2247,8 +2226,8 @@
COMPILE.CC = $(CC_COMPILE) -c
GENASM.CC = $(CC_COMPILE) -S
---- ./hotspot/src/cpu/x86/vm/jni_x86.h Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/cpu/x86/vm/jni_x86.h Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/cpu/x86/vm/jni_x86.h Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/cpu/x86/vm/jni_x86.h Tue May 05 18:06:56 2015 -0700
@@ -34,7 +34,7 @@
#ifndef __has_attribute
#define __has_attribute(x) 0
@@ -2258,8 +2237,8 @@
#define JNIEXPORT __attribute__((visibility("default")))
#define JNIIMPORT __attribute__((visibility("default")))
#else
---- ./hotspot/src/cpu/x86/vm/x86_32.ad Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/cpu/x86/vm/x86_32.ad Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/cpu/x86/vm/x86_32.ad Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/cpu/x86/vm/x86_32.ad Tue May 05 18:06:56 2015 -0700
@@ -1210,6 +1210,7 @@
@@ -2269,7 +2248,7 @@
#ifndef PRODUCT
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./hotspot/src/os/bsd/vm/decoder_bsd.cpp Sat Mar 14 16:41:08 2015 -0700
++++ ./hotspot/src/os/bsd/vm/decoder_bsd.cpp Tue May 05 18:06:56 2015 -0700
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
@@ -2318,8 +2297,8 @@
+ return false;
+}
+#endif
---- ./hotspot/src/os/bsd/vm/jsig.c Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/os/bsd/vm/jsig.c Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/os/bsd/vm/jsig.c Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/os/bsd/vm/jsig.c Tue May 05 18:06:56 2015 -0700
@@ -140,9 +140,8 @@
}
@@ -2332,8 +2311,8 @@
static int call_os_sigaction(int sig, const struct sigaction *act,
struct sigaction *oact) {
---- ./hotspot/src/os/bsd/vm/jvm_bsd.cpp Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/os/bsd/vm/jvm_bsd.cpp Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/os/bsd/vm/jvm_bsd.cpp Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/os/bsd/vm/jvm_bsd.cpp Tue May 05 18:06:56 2015 -0700
@@ -50,6 +50,7 @@
case INTERRUPT_SIGNAL:
case SIGFPE:
@@ -2443,8 +2422,8 @@
+ jio_snprintf(buf, len, "SIG%s", signame);
+ return true;
}
---- ./hotspot/src/os/bsd/vm/jvm_bsd.h Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/os/bsd/vm/jvm_bsd.h Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/os/bsd/vm/jvm_bsd.h Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/os/bsd/vm/jvm_bsd.h Tue May 05 18:06:56 2015 -0700
@@ -112,20 +112,6 @@
#define SHUTDOWN2_SIGNAL SIGINT
#define SHUTDOWN3_SIGNAL SIGTERM
@@ -2466,8 +2445,8 @@
#endif /* JVM_MD_H */
#endif // OS_BSD_VM_JVM_BSD_H
---- ./hotspot/src/os/bsd/vm/osThread_bsd.cpp Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/os/bsd/vm/osThread_bsd.cpp Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/os/bsd/vm/osThread_bsd.cpp Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/os/bsd/vm/osThread_bsd.cpp Tue May 05 18:06:56 2015 -0700
@@ -30,7 +30,7 @@
void OSThread::pd_initialize() {
@@ -2477,8 +2456,8 @@
_thread_id = 0;
#else
_thread_id = NULL;
---- ./hotspot/src/os/bsd/vm/os_bsd.cpp Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/os/bsd/vm/os_bsd.cpp Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/os/bsd/vm/os_bsd.cpp Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/os/bsd/vm/os_bsd.cpp Tue May 05 18:06:56 2015 -0700
@@ -103,10 +103,24 @@
# include <sys/ioctl.h>
# include <sys/syscall.h>
@@ -2815,8 +2794,8 @@
{
int flags = ::fcntl(fd, F_GETFD);
if (flags != -1)
---- ./hotspot/src/os/bsd/vm/vmError_bsd.cpp Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/os/bsd/vm/vmError_bsd.cpp Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/os/bsd/vm/vmError_bsd.cpp Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/os/bsd/vm/vmError_bsd.cpp Tue May 05 18:06:56 2015 -0700
@@ -44,7 +44,7 @@
jio_snprintf(p, buflen - len,
"\n\n"
@@ -2835,8 +2814,8 @@
os::current_process_id(), os::current_process_id());
os::fork_and_exec(buf);
---- ./hotspot/src/share/vm/opto/node.cpp Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/share/vm/opto/node.cpp Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/share/vm/opto/node.cpp Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/share/vm/opto/node.cpp Tue May 05 18:06:56 2015 -0700
@@ -286,6 +286,10 @@
#ifdef _MSC_VER // the IDX_INIT hack falls foul of warning C4355
#pragma warning( disable:4355 ) // 'this' : used in base member initializer list
@@ -2859,8 +2838,8 @@
//------------------------------clone------------------------------------------
// Clone a Node.
---- ./hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp Tue May 05 18:06:56 2015 -0700
@@ -250,7 +250,7 @@
#endif
@@ -2870,29 +2849,8 @@
#define CAN_USE_NAN_DEFINE 1
#endif
---- ./jaxp/.hgtags Wed Jan 28 12:08:37 2015 -0800
-+++ ./jaxp/.hgtags Wed Feb 04 12:14:41 2015 -0800
-@@ -374,3 +374,4 @@
- 78d90db9de2801eec010ccb9f0db3caf969dfc3b jdk8u40-b21
- 54a13451ce243f2159ed3996e6efcf374a5750ca jdk8u40-b22
- e07fbae1efeac4e50514384caa7d226af7414114 jdk8u40-b23
-+048cebd17f73f23ce2295e360f31c1b6788195aa jdk8u40-b24
---- ./jaxws/.hgtags Wed Jan 28 12:08:39 2015 -0800
-+++ ./jaxws/.hgtags Wed Feb 04 12:14:42 2015 -0800
-@@ -372,3 +372,4 @@
- 16485a38b6bc762b363f4e439047486742fbcfcb jdk8u40-b21
- 6e928fd9152541eddf25694be89eb881434a5c5f jdk8u40-b22
- b6755a463ccf6a79b1e1a43ed7bdb1c5cb1ac17d jdk8u40-b23
-+5fbbfd66643edb81cfa0688825d698dcc5f2eb11 jdk8u40-b24
---- ./jdk/.hgtags Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/.hgtags Sat Mar 14 22:56:25 2015 -0700
-@@ -375,3 +375,4 @@
- 564bca490631e4ed4f7993e6633ed9ee62067624 jdk8u40-b21
- d168113f9841a77b3cee3a6a45fcd85b7351ac90 jdk8u40-b22
- 41fe61722ce96b75dd3a1ba5072473122e21e5a0 jdk8u40-b23
-+9d903721276c8684706db7ecfb6cda568e9f4f69 jdk8u40-b24
---- ./jdk/make/CompileDemos.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/CompileDemos.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/CompileDemos.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/CompileDemos.gmk Tue May 05 18:07:05 2015 -0700
@@ -323,7 +323,7 @@
$(eval $(call SetupJVMTIDemo,hprof, java_crw_demo, \
-I$(JDK_TOPDIR)/src/share/npt -I$(JDK_TOPDIR)/src/$(OPENJDK_TARGET_OS_API_DIR)/npt \
@@ -2902,8 +2860,8 @@
$(eval $(call SetupJVMTIDemo,minst, agent_util java_crw_demo))
$(eval $(call SetupJVMTIDemo,mtrace, agent_util java_crw_demo))
---- ./jdk/make/CompileJavaClasses.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/CompileJavaClasses.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/CompileJavaClasses.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/CompileJavaClasses.gmk Tue May 05 18:07:05 2015 -0700
@@ -130,23 +130,32 @@
sun/nio/fs/LinuxFileStore.java \
sun/nio/fs/LinuxFileSystem.java \
@@ -3004,8 +2962,8 @@
$(CLOSED_SRC_DIRS), \
INCLUDES := $(SECURITY_PKGS), \
EXCLUDES := $(EXCLUDES), \
---- ./jdk/make/CompileLaunchers.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/CompileLaunchers.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/CompileLaunchers.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/CompileLaunchers.gmk Tue May 05 18:07:05 2015 -0700
@@ -49,7 +49,7 @@
ORIGIN_ROOT := /..
endif
@@ -3104,8 +3062,8 @@
BUILD_JSPAWNHELPER := 1
endif
---- ./jdk/make/CopyFiles.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/CopyFiles.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/CopyFiles.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/CopyFiles.gmk Tue May 05 18:07:05 2015 -0700
@@ -29,6 +29,8 @@
ifeq ($(OPENJDK_TARGET_OS), windows)
@@ -3148,8 +3106,8 @@
endif
endif
endif
---- ./jdk/make/Images.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/Images.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/Images.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/Images.gmk Tue May 05 18:07:05 2015 -0700
@@ -234,11 +234,11 @@
endif
@@ -3220,7 +3178,7 @@
################################################################################
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/make/data/classlist/classlist.bsd Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/make/data/classlist/classlist.bsd Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,2803 @@
+com/sun/java/swing/SwingUtilities3
+com/sun/java/swing/plaf/windows/WindowsTabbedPaneUI
@@ -6025,8 +5983,8 @@
+sun/util/resources/en/TimeZoneNames_en
+sun/util/spi/CalendarProvider
+# ca392e7ee7285d72
---- ./jdk/make/gendata/GendataFontConfig.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/gendata/GendataFontConfig.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/gendata/GendataFontConfig.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/gendata/GendataFontConfig.gmk Tue May 05 18:07:05 2015 -0700
@@ -73,6 +73,13 @@
GENDATA_FONT_CONFIG_SRC_PREFIX := aix.
endif
@@ -6041,8 +5999,8 @@
###
$(GENDATA_FONT_CONFIG_DST)/%.src: \
---- ./jdk/make/lib/Awt2dLibraries.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/lib/Awt2dLibraries.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/lib/Awt2dLibraries.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/lib/Awt2dLibraries.gmk Tue May 05 18:07:05 2015 -0700
@@ -309,7 +309,7 @@
debug_trace.c \
debug_util.c
@@ -6143,12 +6101,12 @@
# Solaris still uses OPENWIN_LIB ..
LIBSPLASHSCREEN_LDFLAGS_SUFFIX += -L$(OPENWIN_LIB)$(OPENJDK_TARGET_CPU_ISADIR) -lX11 -lXext $(LIBM) -lpthread
+ else ifeq ($(OPENJDK_TARGET_OS), bsd)
-+ LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(X_LIBS) -lX11 -lXext $(LIBM) -liconv -pthread
++ LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(X_LIBS) -lX11 -lXext $(LIBM) -pthread
else # .. all other Unixes can use X_LIBS
LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(X_LIBS) -lX11 -lXext $(LIBM) -lpthread
endif
---- ./jdk/make/lib/CoreLibraries.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/lib/CoreLibraries.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/lib/CoreLibraries.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/lib/CoreLibraries.gmk Tue May 05 18:07:05 2015 -0700
@@ -82,7 +82,7 @@
endif
@@ -6221,8 +6179,8 @@
LDFLAGS_macosx := -liconv, \
LDFLAGS_SUFFIX_windows := -export:nptInitialize -export:nptTerminate, \
LDFLAGS_SUFFIX_solaris := -lc, \
---- ./jdk/make/lib/NetworkingLibraries.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/lib/NetworkingLibraries.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/lib/NetworkingLibraries.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/lib/NetworkingLibraries.gmk Tue May 05 18:07:05 2015 -0700
@@ -42,7 +42,7 @@
LIBNET_EXCLUDE_FILES += linux_close.c
endif
@@ -6240,8 +6198,8 @@
LDFLAGS_SUFFIX_windows := ws2_32.lib jvm.lib secur32.lib iphlpapi.lib \
delayimp.lib $(WIN_JAVA_LIB) advapi32.lib \
-DELAYLOAD:secur32.dll -DELAYLOAD:iphlpapi.dll, \
---- ./jdk/make/lib/NioLibraries.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/lib/NioLibraries.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/lib/NioLibraries.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/lib/NioLibraries.gmk Tue May 05 18:07:05 2015 -0700
@@ -77,9 +77,28 @@
UnixNativeDispatcher.c
endif
@@ -6302,8 +6260,8 @@
endif
+ endif
endif
---- ./jdk/make/lib/ServiceabilityLibraries.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/lib/ServiceabilityLibraries.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/lib/ServiceabilityLibraries.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/lib/ServiceabilityLibraries.gmk Tue May 05 18:07:05 2015 -0700
@@ -34,7 +34,7 @@
ifneq ($(OPENJDK_TARGET_OS), linux)
LIBATTACH_EXCLUDE_FILES += LinuxVirtualMachine.c
@@ -6381,8 +6339,8 @@
ifeq ($(ENABLE_DEBUG_SYMBOLS), true)
LIBHPROF_OPTIMIZATION := LOW
endif
---- ./jdk/make/lib/SoundLibraries.gmk Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/lib/SoundLibraries.gmk Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/lib/SoundLibraries.gmk Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/lib/SoundLibraries.gmk Tue May 05 18:07:05 2015 -0700
@@ -75,6 +75,11 @@
LIBJSOUND_CFLAGS += -DX_PLATFORM=X_AIX
endif # OPENJDK_TARGET_OS aix
@@ -6412,8 +6370,8 @@
LDFLAGS_SUFFIX := $(ALSA_LIBS) -ljava -ljvm, \
OBJECT_DIR := $(JDK_OUTPUTDIR)/objs/libjsoundalsa, \
DEBUG_SYMBOLS := $(DEBUG_ALL_BINARIES)))
---- ./jdk/make/mapfiles/launchers/mapfile-x86 Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/mapfiles/launchers/mapfile-x86 Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/mapfiles/launchers/mapfile-x86 Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/mapfiles/launchers/mapfile-x86 Tue May 05 18:07:05 2015 -0700
@@ -33,6 +33,7 @@
environ; # Public symbols and required by Java run time
_environ;
@@ -6422,8 +6380,8 @@
___Argv; # The following are private, but as they are
_start; # exported from ctr1/crtn, the clever hacker
_init; # might know about them. However note, that
---- ./jdk/make/mapfiles/launchers/mapfile-x86_64 Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/mapfiles/launchers/mapfile-x86_64 Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/mapfiles/launchers/mapfile-x86_64 Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/mapfiles/launchers/mapfile-x86_64 Tue May 05 18:07:05 2015 -0700
@@ -33,6 +33,7 @@
environ; # Public symbols and required by Java run time
_environ;
@@ -6433,7 +6391,7 @@
local:
*;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/make/mapfiles/libattach/mapfile-bsd Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/make/mapfiles/libattach/mapfile-bsd Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,42 @@
+#
+# Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
@@ -6478,7 +6436,7 @@
+ *;
+};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/make/mapfiles/libnio/mapfile-bsd Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/make/mapfiles/libnio/mapfile-bsd Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,195 @@
+#
+# Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
@@ -6675,8 +6633,8 @@
+ local:
+ *;
+};
---- ./jdk/make/mapfiles/libunpack/mapfile-vers-unpack200 Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/mapfiles/libunpack/mapfile-vers-unpack200 Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/mapfiles/libunpack/mapfile-vers-unpack200 Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/mapfiles/libunpack/mapfile-vers-unpack200 Tue May 05 18:07:05 2015 -0700
@@ -26,6 +26,9 @@
# Define library interface.
@@ -6688,7 +6646,7 @@
*;
};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/make/netbeans/common/bsd-sources.ent Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/make/netbeans/common/bsd-sources.ent Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
@@ -6736,7 +6694,7 @@
+ <location>${root}/src/bsd/classes</location>
+</source-folder>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/make/netbeans/common/bsd-view.ent Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/make/netbeans/common/bsd-view.ent Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
@@ -6777,8 +6735,8 @@
+ <includes>${includes}</includes>
+ <excludes>${excludes}</excludes>
+</source-folder>
---- ./jdk/make/netbeans/common/java-data-native.ent Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/netbeans/common/java-data-native.ent Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/netbeans/common/java-data-native.ent Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/netbeans/common/java-data-native.ent Tue May 05 18:07:05 2015 -0700
@@ -34,6 +34,7 @@
<java-data xmlns="http://www.netbeans.org/ns/freeform-project-java/4">
<compilation-unit>
@@ -6787,8 +6745,8 @@
<package-root>${root}/src/macosx/classes</package-root>
<package-root>${root}/src/solaris/classes</package-root>
<package-root>${root}/src/windows/classes</package-root>
---- ./jdk/make/netbeans/common/make.xml Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/netbeans/common/make.xml Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/netbeans/common/make.xml Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/netbeans/common/make.xml Tue May 05 18:07:05 2015 -0700
@@ -32,16 +32,21 @@
-->
@@ -6823,8 +6781,8 @@
<macrodef name="make-run">
<attribute name="target"/>
<attribute name="dir"/>
---- ./jdk/make/netbeans/j2se/nbproject/project.xml Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/netbeans/j2se/nbproject/project.xml Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/netbeans/j2se/nbproject/project.xml Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/netbeans/j2se/nbproject/project.xml Tue May 05 18:07:05 2015 -0700
@@ -34,6 +34,7 @@
<!DOCTYPE project [
<!ENTITY properties SYSTEM "../../common/properties.ent">
@@ -6857,8 +6815,8 @@
&macosx-view;
&unix-view;
&windows-view;
---- ./jdk/make/netbeans/world/nbproject/project.xml Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/make/netbeans/world/nbproject/project.xml Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/make/netbeans/world/nbproject/project.xml Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/make/netbeans/world/nbproject/project.xml Tue May 05 18:07:05 2015 -0700
@@ -34,12 +34,14 @@
<!DOCTYPE project [
<!ENTITY properties SYSTEM "../../common/properties.ent">
@@ -6891,7 +6849,7 @@
&unix-view;
&windows-view;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/src/bsd/classes/java/net/DefaultInterface.java Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/src/bsd/classes/java/net/DefaultInterface.java Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
@@ -6991,7 +6949,7 @@
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/src/bsd/classes/sun/nio/ch/DefaultSelectorProvider.java Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/src/bsd/classes/sun/nio/ch/DefaultSelectorProvider.java Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
@@ -7042,7 +7000,7 @@
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/src/bsd/classes/sun/nio/ch/KQueueArrayWrapper.java Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/src/bsd/classes/sun/nio/ch/KQueueArrayWrapper.java Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
@@ -7258,7 +7216,7 @@
+ private static native void interrupt(int fd);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/src/bsd/classes/sun/nio/ch/KQueueSelectorImpl.java Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/src/bsd/classes/sun/nio/ch/KQueueSelectorImpl.java Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
@@ -7510,7 +7468,7 @@
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/src/bsd/classes/sun/nio/ch/KQueueSelectorProvider.java Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/src/bsd/classes/sun/nio/ch/KQueueSelectorProvider.java Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
@@ -7556,8 +7514,50 @@
+ return new KQueueSelectorImpl(this);
+ }
+}
+--- ./jdk/src/bsd/doc/man/javah.1 Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/bsd/doc/man/javah.1 Tue May 05 18:07:05 2015 -0700
+@@ -110,7 +110,7 @@
+
+ \&.:\fIyour-path\fR
+
+-Example: \f3\&.:/home/avh/classes:/usr/local/java/classes\fR
++Example: \f3\&.:/home/avh/classes:/usr/local/share/java/classes\fR
+
+ \fIWindows\fR:
+
+--- ./jdk/src/bsd/doc/man/rmic.1 Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/bsd/doc/man/rmic.1 Tue May 05 18:07:05 2015 -0700
+@@ -93,7 +93,7 @@
+ .TP
+ -classpath path
+ .br
+-Specifies the path the \f3rmic\fR command uses to look up classes\&. This option overrides the default or the \f3CLASSPATH\fR environment variable when it is set\&. Directories are separated by colons\&. The general format for path is: \f3\&.:<your_path>\fR, for example: \f3\&.:/usr/local/java/classes\fR\&.
++Specifies the path the \f3rmic\fR command uses to look up classes\&. This option overrides the default or the \f3CLASSPATH\fR environment variable when it is set\&. Directories are separated by colons\&. The general format for path is: \f3\&.:<your_path>\fR, for example: \f3\&.:/usr/local/share/java/classes\fR\&.
+ .TP
+ -d \fIdirectory\fR
+ .br
+@@ -207,7 +207,7 @@
+ .SH ENVIRONMENT\ VARIABLES
+ .TP
+ CLASSPATH
+-Used to provide the system a path to user-defined classes\&. Directories are separated by colons, for example: \f3\&.:/usr/local/java/classes\fR\&.
++Used to provide the system a path to user-defined classes\&. Directories are separated by colons, for example: \f3\&.:/usr/local/share/java/classes\fR\&.
+ .SH SEE\ ALSO
+ .TP 0.2i
+ \(bu
+--- ./jdk/src/bsd/doc/man/rmid.1 Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/bsd/doc/man/rmid.1 Tue May 05 18:07:05 2015 -0700
+@@ -301,7 +301,7 @@
+ .SH ENVIRONMENT\ VARIABLES
+ .TP
+ CLASSPATH
+-Used to provide the system a path to user-defined classes\&. Directories are separated by colons, for example: \f3\&.:/usr/local/java/classes\fR\&.
++Used to provide the system a path to user-defined classes\&. Directories are separated by colons, for example: \f3\&.:/usr/local/share/java/classes\fR\&.
+ .SH SEE\ ALSO
+ .TP 0.2i
+ \(bu
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/src/bsd/native/sun/nio/ch/KQueueArrayWrapper.c Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/src/bsd/native/sun/nio/ch/KQueueArrayWrapper.c Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
@@ -7730,7 +7730,7 @@
+ }
+}
+
---- ./jdk/src/macosx/classes/java/net/DefaultInterface.java Mon Feb 02 10:12:21 2015 -0800
+--- ./jdk/src/macosx/classes/java/net/DefaultInterface.java Tue Mar 17 00:09:12 2015 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,97 +0,0 @@
-/*
@@ -7830,7 +7830,7 @@
- return (ppp != null) ? ppp : loopback;
- }
-}
---- ./jdk/src/macosx/classes/sun/nio/ch/DefaultSelectorProvider.java Mon Feb 02 10:12:21 2015 -0800
+--- ./jdk/src/macosx/classes/sun/nio/ch/DefaultSelectorProvider.java Tue Mar 17 00:09:12 2015 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-/*
@@ -7881,7 +7881,7 @@
- }
-
-}
---- ./jdk/src/macosx/classes/sun/nio/ch/KQueueArrayWrapper.java Mon Feb 02 10:12:21 2015 -0800
+--- ./jdk/src/macosx/classes/sun/nio/ch/KQueueArrayWrapper.java Tue Mar 17 00:09:12 2015 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,213 +0,0 @@
-/*
@@ -8097,7 +8097,7 @@
- long timeout);
- private static native void interrupt(int fd);
-}
---- ./jdk/src/macosx/classes/sun/nio/ch/KQueueSelectorImpl.java Mon Feb 02 10:12:21 2015 -0800
+--- ./jdk/src/macosx/classes/sun/nio/ch/KQueueSelectorImpl.java Tue Mar 17 00:09:12 2015 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,249 +0,0 @@
-/*
@@ -8349,7 +8349,7 @@
- return this;
- }
-}
---- ./jdk/src/macosx/classes/sun/nio/ch/KQueueSelectorProvider.java Mon Feb 02 10:12:21 2015 -0800
+--- ./jdk/src/macosx/classes/sun/nio/ch/KQueueSelectorProvider.java Tue Mar 17 00:09:12 2015 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-/*
@@ -8396,7 +8396,7 @@
- return new KQueueSelectorImpl(this);
- }
-}
---- ./jdk/src/macosx/native/sun/nio/ch/KQueueArrayWrapper.c Mon Feb 02 10:12:21 2015 -0800
+--- ./jdk/src/macosx/native/sun/nio/ch/KQueueArrayWrapper.c Tue Mar 17 00:09:12 2015 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,171 +0,0 @@
-/*
@@ -8570,8 +8570,8 @@
- }
-}
-
---- ./jdk/src/share/bin/jli_util.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/bin/jli_util.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/bin/jli_util.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/bin/jli_util.h Tue May 05 18:07:05 2015 -0700
@@ -87,7 +87,7 @@
#define _LARGFILE64_SOURCE
#define JLI_Lseek lseek64
@@ -8581,8 +8581,8 @@
#define JLI_Lseek lseek
#endif
#ifdef _AIX
---- ./jdk/src/share/classes/sun/awt/FontConfiguration.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/awt/FontConfiguration.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/awt/FontConfiguration.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/awt/FontConfiguration.java Tue May 05 18:07:05 2015 -0700
@@ -1146,7 +1146,7 @@
*/
HashMap<String, Boolean> existsMap;
@@ -8592,8 +8592,8 @@
return false;
} else if (existsMap == null) {
existsMap = new HashMap<String, Boolean>();
---- ./jdk/src/share/classes/sun/awt/OSInfo.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/awt/OSInfo.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/awt/OSInfo.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/awt/OSInfo.java Tue May 05 18:07:05 2015 -0700
@@ -39,6 +39,7 @@
WINDOWS,
LINUX,
@@ -8613,8 +8613,8 @@
if (osName.contains("OS X")) {
return MACOSX;
}
---- ./jdk/src/share/classes/sun/font/FontUtilities.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/font/FontUtilities.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/font/FontUtilities.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/font/FontUtilities.java Tue May 05 18:07:05 2015 -0700
@@ -48,6 +48,8 @@
public static boolean isLinux;
@@ -8633,8 +8633,8 @@
isMacOSX = osName.contains("OS X"); // TODO: MacOSX
String t2kStr = System.getProperty("sun.java2d.font.scaler");
---- ./jdk/src/share/classes/sun/font/SunFontManager.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/font/SunFontManager.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/font/SunFontManager.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/font/SunFontManager.java Tue May 05 18:07:05 2015 -0700
@@ -418,7 +418,7 @@
* registerFonts method as on-screen these JRE fonts
* always go through the T2K rasteriser.
@@ -8644,8 +8644,8 @@
/* Linux font configuration uses these fonts */
registerFontDir(jreFontDirName);
}
---- ./jdk/src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java Tue May 05 18:07:05 2015 -0700
@@ -1298,7 +1298,7 @@
String osName = AccessController.doPrivileged(
new GetPropertyAction("os.name"));
@@ -8655,8 +8655,8 @@
charset("x-COMPOUND_TEXT", "COMPOUND_TEXT",
new String[] {
"COMPOUND_TEXT", // JDK historical
---- ./jdk/src/share/classes/sun/print/PSPrinterJob.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/print/PSPrinterJob.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/print/PSPrinterJob.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/print/PSPrinterJob.java Tue May 05 18:07:05 2015 -0700
@@ -1587,7 +1587,7 @@
}
@@ -8666,8 +8666,8 @@
execCmd = new String[ncomps];
execCmd[n++] = "/usr/bin/lpr";
if ((pFlags & PRINTER) != 0) {
---- ./jdk/src/share/classes/sun/security/jgss/GSSManagerImpl.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/security/jgss/GSSManagerImpl.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/security/jgss/GSSManagerImpl.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/security/jgss/GSSManagerImpl.java Tue May 05 18:07:05 2015 -0700
@@ -48,6 +48,7 @@
public Boolean run() {
String osname = System.getProperty("os.name");
@@ -8676,8 +8676,8 @@
osname.contains("OS X") ||
osname.startsWith("Linux")) {
return new Boolean(System.getProperty
---- ./jdk/src/share/classes/sun/security/jgss/wrapper/SunNativeProvider.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/security/jgss/wrapper/SunNativeProvider.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/security/jgss/wrapper/SunNativeProvider.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/security/jgss/wrapper/SunNativeProvider.java Tue May 05 18:07:05 2015 -0700
@@ -90,6 +90,12 @@
"libgssapi_krb5.so",
"libgssapi_krb5.so.2",
@@ -8691,8 +8691,8 @@
} else if (osname.contains("OS X")) {
gssLibs = new String[]{
"libgssapi_krb5.dylib",
---- ./jdk/src/share/classes/sun/tools/attach/META-INF/services/com.sun.tools.attach.spi.AttachProvider Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/classes/sun/tools/attach/META-INF/services/com.sun.tools.attach.spi.AttachProvider Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/classes/sun/tools/attach/META-INF/services/com.sun.tools.attach.spi.AttachProvider Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/classes/sun/tools/attach/META-INF/services/com.sun.tools.attach.spi.AttachProvider Tue May 05 18:07:05 2015 -0700
@@ -31,4 +31,5 @@
#[windows]sun.tools.attach.WindowsAttachProvider
#[linux]sun.tools.attach.LinuxAttachProvider
@@ -8700,7 +8700,7 @@
+#[bsd]sun.tools.attach.BsdAttachProvider
#[aix]sun.tools.attach.AixAttachProvider
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
-+++ ./jdk/src/share/lib/security/java.security-bsd Sat Mar 14 22:56:25 2015 -0700
++++ ./jdk/src/share/lib/security/java.security-bsd Tue May 05 18:07:05 2015 -0700
@@ -0,0 +1,498 @@
+#
+# This is the "master security properties file".
@@ -9200,8 +9200,8 @@
+#
+# Example:
+# jdk.tls.disabledAlgorithms=MD5, SHA1, DSA, RSA keySize < 2048
---- ./jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp Tue May 05 18:07:05 2015 -0700
@@ -62,7 +62,7 @@
#endif // End of ZLIB
@@ -9211,8 +9211,8 @@
#define SWAP_BYTES(a) \
((((a) << 8) & 0xff00) | 0x00ff) & (((a) >> 8) | 0xff00)
#else
---- ./jdk/src/share/native/com/sun/media/sound/DirectAudioDevice.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/com/sun/media/sound/DirectAudioDevice.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/com/sun/media/sound/DirectAudioDevice.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/com/sun/media/sound/DirectAudioDevice.c Tue May 05 18:07:05 2015 -0700
@@ -121,7 +121,7 @@
}
@@ -9240,8 +9240,8 @@
#define MAP_NATIVE2LE16(a) (a)
#define MAP_NATIVE2BE16(a) MAP_SWAP16_impl(a)
#define MAP_NATIVE2LE32(a) (a)
---- ./jdk/src/share/native/com/sun/media/sound/Utilities.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/com/sun/media/sound/Utilities.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/com/sun/media/sound/Utilities.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/com/sun/media/sound/Utilities.c Tue May 05 18:07:05 2015 -0700
@@ -28,7 +28,7 @@
@@ -9251,8 +9251,8 @@
return 0;
#else
return 1;
---- ./jdk/src/share/native/java/lang/fdlibm/include/fdlibm.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/java/lang/fdlibm/include/fdlibm.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/java/lang/fdlibm/include/fdlibm.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/java/lang/fdlibm/include/fdlibm.h Tue May 05 18:07:05 2015 -0700
@@ -40,7 +40,7 @@
#endif
#endif
@@ -9262,8 +9262,8 @@
#define __HI(x) *(1+(int*)&x)
#define __LO(x) *(int*)&x
#define __HIp(x) *(1+(int*)x)
---- ./jdk/src/share/native/sun/awt/image/awt_parseImage.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/image/awt_parseImage.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/image/awt_parseImage.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/image/awt_parseImage.c Tue May 05 18:07:05 2015 -0700
@@ -624,7 +624,7 @@
switch(type) {
case java_awt_image_BufferedImage_TYPE_INT_ARGB:
@@ -9291,8 +9291,8 @@
colorOrder[0] = 2;
colorOrder[1] = 1;
colorOrder[2] = 0;
---- ./jdk/src/share/native/sun/awt/medialib/awt_ImagingLib.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/awt_ImagingLib.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/awt_ImagingLib.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/awt_ImagingLib.c Tue May 05 18:07:05 2015 -0700
@@ -1176,7 +1176,7 @@
#define NLUT 8
@@ -9302,8 +9302,8 @@
#define INDEXES { 3, 2, 1, 0, 7, 6, 5, 4 }
#else
#define INDEXES { 0, 1, 2, 3, 4, 5, 6, 7 }
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv2x2_f.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv2x2_f.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv2x2_f.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv2x2_f.c Tue May 05 18:07:05 2015 -0700
@@ -86,7 +86,7 @@
#endif /* MLIB_USE_FTOI_CLAMPING */
@@ -9343,8 +9343,8 @@
#endif /* _NO_LONGLONG */
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16ext.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16ext.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16ext.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16ext.c Tue May 05 18:07:05 2015 -0700
@@ -126,7 +126,7 @@
#define D2I(x) CLAMP_S32((x) SAT_OFF)
@@ -9384,8 +9384,8 @@
#endif /* _NO_LONGLONG */
/***************************************************************/
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16nw.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16nw.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16nw.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_16nw.c Tue May 05 18:07:05 2015 -0700
@@ -94,7 +94,7 @@
#define D2I(x) CLAMP_S32((x) SAT_OFF)
@@ -9425,8 +9425,8 @@
#endif /* _NO_LONGLONG */
/***************************************************************/
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8ext.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8ext.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8ext.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8ext.c Tue May 05 18:07:05 2015 -0700
@@ -126,7 +126,7 @@
#define D2I(x) CLAMP_S32((x) SAT_OFF)
@@ -9466,8 +9466,8 @@
#endif /* _NO_LONGLONG */
/***************************************************************/
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8nw.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8nw.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8nw.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_8nw.c Tue May 05 18:07:05 2015 -0700
@@ -95,7 +95,7 @@
#define D2I(x) CLAMP_S32((x) SAT_OFF)
@@ -9507,8 +9507,8 @@
#endif /* _NO_LONGLONG */
/***************************************************************/
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16ext.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16ext.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16ext.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16ext.c Tue May 05 18:07:05 2015 -0700
@@ -126,7 +126,7 @@
#define D2I(x) CLAMP_S32((x) SAT_OFF)
@@ -9548,8 +9548,8 @@
#endif /* _NO_LONGLONG */
/***************************************************************/
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16nw.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16nw.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16nw.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageConv_u16nw.c Tue May 05 18:07:05 2015 -0700
@@ -94,7 +94,7 @@
#define D2I(x) CLAMP_S32((x) SAT_OFF)
@@ -9589,8 +9589,8 @@
#endif /* _NO_LONGLONG */
/***************************************************************/
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageCopy_Bit.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageCopy_Bit.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageCopy_Bit.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageCopy_Bit.c Tue May 05 18:07:05 2015 -0700
@@ -95,7 +95,7 @@
dst = dp[0];
if (ld_offset + size < 32) {
@@ -9810,8 +9810,8 @@
}
#else /* _LONGLONG */
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_64.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_64.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_64.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_64.c Tue May 05 18:07:05 2015 -0700
@@ -168,7 +168,7 @@
}
@@ -10092,8 +10092,8 @@
dp[12] = t0;
dp[13] = t1;
dp[14] = t2;
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_Bit.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_Bit.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_Bit.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageLookUp_Bit.c Tue May 05 18:07:05 2015 -0700
@@ -88,7 +88,7 @@
} d64_2_f32;
@@ -10245,8 +10245,8 @@
((mlib_u32*)lh)[0] = l; ((mlib_u32*)lh)[1] = l;
((mlib_u32*)lh)[2] = l; ((mlib_u32*)lh)[3] = h;
---- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageUtils.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageUtils.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_ImageUtils.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_ImageUtils.c Tue May 05 18:07:05 2015 -0700
@@ -30,7 +30,7 @@
typedef union {
mlib_d64 db;
@@ -10256,8 +10256,8 @@
mlib_s32 int1, int0;
#else
mlib_s32 int0, int1;
---- ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageCopy.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageCopy.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageCopy.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageCopy.c Tue May 05 18:07:05 2015 -0700
@@ -275,11 +275,11 @@
for (i = 0; j <= (b_size - 4); j += 4, i++) {
src0 = src1;
@@ -10356,8 +10356,8 @@
s0 = s1;
dp += SIZE;
sp += SIZE;
---- ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageLookUp_f.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageLookUp_f.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageLookUp_f.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_c_ImageLookUp_f.c Tue May 05 18:07:05 2015 -0700
@@ -120,7 +120,7 @@
} \
}
@@ -11590,8 +11590,8 @@
dp[12] = t0;
dp[13] = t1;
dp[14] = t2;
---- ./jdk/src/share/native/sun/awt/medialib/mlib_image.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_image.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_image.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_image.h Tue May 05 18:07:05 2015 -0700
@@ -27,9 +27,6 @@
#ifndef MLIB_IMAGE_H
#define MLIB_IMAGE_H
@@ -11602,8 +11602,8 @@
#include <mlib_types.h>
#include <mlib_status.h>
#include <mlib_sys.h>
---- ./jdk/src/share/native/sun/awt/medialib/mlib_sys.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/awt/medialib/mlib_sys.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/awt/medialib/mlib_sys.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/awt/medialib/mlib_sys.c Tue May 05 18:07:05 2015 -0700
@@ -29,7 +29,7 @@
#ifdef MACOSX
#include <unistd.h>
@@ -11623,8 +11623,8 @@
#else
return (void *) memalign(8, size);
#endif /* _MSC_VER */
---- ./jdk/src/share/native/sun/font/layout/LEStandalone.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/font/layout/LEStandalone.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/font/layout/LEStandalone.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/font/layout/LEStandalone.h Tue May 05 18:07:05 2015 -0700
@@ -136,7 +136,7 @@
#define U_CAPI extern "C"
@@ -11634,8 +11634,8 @@
#define U_IS_BIG_ENDIAN 0
#endif
#endif
---- ./jdk/src/share/native/sun/java2d/cmm/lcms/LCMS.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/java2d/cmm/lcms/LCMS.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/java2d/cmm/lcms/LCMS.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/java2d/cmm/lcms/LCMS.c Tue May 05 18:07:05 2015 -0700
@@ -182,7 +182,7 @@
return 0L;
}
@@ -11645,8 +11645,8 @@
/* Reversing data packed into int for LE archs */
if (isInIntPacked) {
inFormatter ^= DOSWAP_SH(1);
---- ./jdk/src/share/native/sun/management/DiagnosticCommandImpl.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/share/native/sun/management/DiagnosticCommandImpl.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/share/native/sun/management/DiagnosticCommandImpl.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/share/native/sun/management/DiagnosticCommandImpl.c Tue May 05 18:07:05 2015 -0700
@@ -27,6 +27,7 @@
#include <jni.h>
#include "management.h"
@@ -11655,8 +11655,8 @@
JNIEXPORT void JNICALL Java_sun_management_DiagnosticCommandImpl_setNotificationEnabled
(JNIEnv *env, jobject dummy, jboolean enabled) {
---- ./jdk/src/solaris/back/util_md.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/back/util_md.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/back/util_md.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/back/util_md.h Tue May 05 18:07:05 2015 -0700
@@ -51,7 +51,7 @@
/* On little endian machines, convert java big endian numbers. */
@@ -11666,8 +11666,8 @@
#define HOST_TO_JAVA_CHAR(x) (((x & 0xff) << 8) | ((x >> 8) & (0xff)))
#define HOST_TO_JAVA_SHORT(x) (((x & 0xff) << 8) | ((x >> 8) & (0xff)))
---- ./jdk/src/solaris/bin/ergo_i586.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/bin/ergo_i586.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/bin/ergo_i586.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/bin/ergo_i586.c Tue May 05 18:07:05 2015 -0700
@@ -106,7 +106,7 @@
#endif /* __solaris__ */
@@ -11686,8 +11686,8 @@
/*
* Routines shared by solaris-i586 and linux-i586.
---- ./jdk/src/solaris/bin/java_md_solinux.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/bin/java_md_solinux.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/bin/java_md_solinux.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/bin/java_md_solinux.c Tue May 05 18:07:05 2015 -0700
@@ -306,9 +306,9 @@
if (llp == NULL && dmllp == NULL) {
return JNI_FALSE;
@@ -11774,8 +11774,8 @@
}
int
---- ./jdk/src/solaris/bin/java_md_solinux.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/bin/java_md_solinux.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/bin/java_md_solinux.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/bin/java_md_solinux.h Tue May 05 18:07:05 2015 -0700
@@ -26,17 +26,26 @@
#ifndef JAVA_MD_SOLINUX_H
#define JAVA_MD_SOLINUX_H
@@ -11816,8 +11816,8 @@
#else /* !__solaris__, i.e. Linux, AIX,.. */
static const char *system_dir = "/usr/java";
static const char *user_dir = "/java";
---- ./jdk/src/solaris/classes/java/lang/UNIXProcess.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/java/lang/UNIXProcess.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/java/lang/UNIXProcess.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/java/lang/UNIXProcess.java Tue May 05 18:07:05 2015 -0700
@@ -82,6 +82,8 @@
LINUX(LaunchMechanism.VFORK, LaunchMechanism.FORK),
@@ -11865,8 +11865,8 @@
case BSD:
case AIX:
// There is a risk that pid will be recycled, causing us to
---- ./jdk/src/solaris/classes/sun/awt/X11FontManager.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/awt/X11FontManager.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/awt/X11FontManager.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/awt/X11FontManager.java Tue May 05 18:07:05 2015 -0700
@@ -236,7 +236,7 @@
if (fontID != null) {
fileName = (String)fontNameMap.get(fontID);
@@ -11894,8 +11894,8 @@
(!mFontConfig.foundOsSpecificFile() ||
!mFontConfig.fontFilesArePresent()) ||
(FontUtilities.isSolaris && !mFontConfig.fontFilesArePresent()))) {
---- ./jdk/src/solaris/classes/sun/awt/fontconfigs/bsd.fontconfig.properties Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/awt/fontconfigs/bsd.fontconfig.properties Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/awt/fontconfigs/bsd.fontconfig.properties Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/awt/fontconfigs/bsd.fontconfig.properties Tue May 05 18:07:05 2015 -0700
@@ -26,134 +26,134 @@
# Version
@@ -12158,8 +12158,8 @@
+filename.NanumGothic_Bold=/usr/local/lib/X11/fonts/nanum-ttf/NanumGothicBold.ttf
+filename.NanumMyeongjo=/usr/local/lib/X11/fonts/nanum-ttf/NanumMyeongjo.ttf
+filename.NanumMyeongjo_Bold=/usr/local/lib/X11/fonts/nanum-ttf/NanumMyeongjoBold.ttf
---- ./jdk/src/solaris/classes/sun/net/PortConfig.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/net/PortConfig.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/net/PortConfig.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/net/PortConfig.java Tue May 05 18:07:05 2015 -0700
@@ -52,7 +52,7 @@
} else if (os.startsWith("SunOS")) {
defaultLower = 32768;
@@ -12169,8 +12169,8 @@
defaultLower = 49152;
defaultUpper = 65535;
} else if (os.startsWith("AIX")) {
---- ./jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java Tue May 05 18:07:05 2015 -0700
@@ -66,7 +66,7 @@
return createProvider("sun.nio.ch.SolarisAsynchronousChannelProvider");
if (osname.equals("Linux"))
@@ -12180,8 +12180,8 @@
return createProvider("sun.nio.ch.BsdAsynchronousChannelProvider");
if (osname.equals("AIX"))
return createProvider("sun.nio.ch.AixAsynchronousChannelProvider");
---- ./jdk/src/solaris/classes/sun/nio/fs/BsdFileSystemProvider.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/nio/fs/BsdFileSystemProvider.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/nio/fs/BsdFileSystemProvider.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/nio/fs/BsdFileSystemProvider.java Tue May 05 18:07:05 2015 -0700
@@ -25,10 +25,14 @@
package sun.nio.fs;
@@ -12215,8 +12215,8 @@
+ new MagicFileTypeDetector());
+ }
}
---- ./jdk/src/solaris/classes/sun/nio/fs/DefaultFileSystemProvider.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/nio/fs/DefaultFileSystemProvider.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/nio/fs/DefaultFileSystemProvider.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/nio/fs/DefaultFileSystemProvider.java Tue May 05 18:07:05 2015 -0700
@@ -61,6 +61,8 @@
return createProvider("sun.nio.fs.SolarisFileSystemProvider");
if (osname.equals("Linux"))
@@ -12226,8 +12226,8 @@
if (osname.contains("OS X"))
return createProvider("sun.nio.fs.MacOSXFileSystemProvider");
if (osname.equals("AIX"))
---- ./jdk/src/solaris/classes/sun/print/UnixPrintServiceLookup.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/print/UnixPrintServiceLookup.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/print/UnixPrintServiceLookup.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/print/UnixPrintServiceLookup.java Tue May 05 18:07:05 2015 -0700
@@ -161,6 +161,7 @@
static boolean isBSD() {
@@ -12251,8 +12251,8 @@
"/usr/sbin/lpc status all | grep -E '^[ 0-9a-zA-Z_-]*@' | awk -F'@' '{print $1}' | sort"
};
---- ./jdk/src/solaris/classes/sun/tools/attach/BsdVirtualMachine.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/classes/sun/tools/attach/BsdVirtualMachine.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/classes/sun/tools/attach/BsdVirtualMachine.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/classes/sun/tools/attach/BsdVirtualMachine.java Tue May 05 18:07:05 2015 -0700
@@ -273,7 +273,7 @@
try {
b = s.getBytes("UTF-8");
@@ -12262,8 +12262,8 @@
}
BsdVirtualMachine.write(fd, b, 0, b.length);
}
---- ./jdk/src/solaris/native/com/sun/media/sound/PLATFORM_API_SolarisOS_PCM.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/com/sun/media/sound/PLATFORM_API_SolarisOS_PCM.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/com/sun/media/sound/PLATFORM_API_SolarisOS_PCM.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/com/sun/media/sound/PLATFORM_API_SolarisOS_PCM.c Tue May 05 18:07:05 2015 -0700
@@ -140,7 +140,7 @@
(float) ((int) sr->samp_rates[s]),
DAUDIO_PCM, /* encoding - let's only do PCM */
@@ -12273,8 +12273,8 @@
FALSE /* little endian */
#else
(bits[b] > 8)?TRUE:FALSE /* big endian */
---- ./jdk/src/solaris/native/common/jni_util_md.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/common/jni_util_md.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/common/jni_util_md.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/common/jni_util_md.c Tue May 05 18:07:05 2015 -0700
@@ -28,6 +28,7 @@
#include "jni.h"
#include "jni_util.h"
@@ -12283,8 +12283,8 @@
jstring nativeNewStringPlatform(JNIEnv *env, const char *str) {
return NULL;
---- ./jdk/src/solaris/native/java/lang/java_props_md.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/lang/java_props_md.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/lang/java_props_md.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/lang/java_props_md.c Tue May 05 18:07:05 2015 -0700
@@ -151,7 +151,7 @@
lc = setlocale(cat, NULL);
#endif
@@ -12319,8 +12319,8 @@
/* user properties */
{
---- ./jdk/src/solaris/native/java/net/Inet4AddressImpl.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/net/Inet4AddressImpl.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/net/Inet4AddressImpl.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/net/Inet4AddressImpl.c Tue May 05 18:07:05 2015 -0700
@@ -36,20 +36,13 @@
#include <stdlib.h>
#include <ctype.h>
@@ -12639,8 +12639,8 @@
#define SET_NONBLOCKING(fd) { \
int flags = fcntl(fd, F_GETFL); \
flags |= O_NONBLOCK; \
---- ./jdk/src/solaris/native/java/net/Inet6AddressImpl.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/net/Inet6AddressImpl.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/net/Inet6AddressImpl.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/net/Inet6AddressImpl.c Tue May 05 18:07:05 2015 -0700
@@ -33,7 +33,7 @@
#include <strings.h>
#include <stdlib.h>
@@ -12671,8 +12671,8 @@
/*
* If we're looking up the local machine, attempt to get the address
* from getifaddrs. This ensures we get an IPv6 address for the local
---- ./jdk/src/solaris/native/java/net/NetworkInterface.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/net/NetworkInterface.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/net/NetworkInterface.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/net/NetworkInterface.c Tue May 05 18:07:05 2015 -0700
@@ -67,14 +67,18 @@
#include <sys/param.h>
#include <sys/ioctl.h>
@@ -12694,8 +12694,8 @@
#include "jvm.h"
#include "jni_util.h"
---- ./jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c Tue May 05 18:07:05 2015 -0700
@@ -2200,7 +2200,7 @@
}
}
@@ -12705,8 +12705,8 @@
if (family == AF_INET6 && index == 0) {
index = getDefaultScopeID(env);
}
---- ./jdk/src/solaris/native/java/net/bsd_close.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/net/bsd_close.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/net/bsd_close.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/net/bsd_close.c Tue May 05 18:07:05 2015 -0700
@@ -316,11 +316,8 @@
}
@@ -12721,8 +12721,8 @@
}
int NET_Connect(int s, struct sockaddr *addr, int addrlen) {
---- ./jdk/src/solaris/native/java/net/net_util_md.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/net/net_util_md.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/net/net_util_md.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/net/net_util_md.c Tue May 05 18:07:05 2015 -0700
@@ -87,7 +87,7 @@
void setDefaultScopeID(JNIEnv *env, struct sockaddr *him)
@@ -12732,8 +12732,8 @@
static jclass ni_class = NULL;
static jfieldID ni_defaultIndexID;
if (ni_class == NULL) {
---- ./jdk/src/solaris/native/java/net/net_util_md.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/net/net_util_md.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/net/net_util_md.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/net/net_util_md.h Tue May 05 18:07:05 2015 -0700
@@ -47,7 +47,7 @@
close subroutine does not return until the select call returns.
...
@@ -12743,8 +12743,8 @@
extern int NET_Timeout(int s, long timeout);
extern int NET_Read(int s, void* buf, size_t len);
extern int NET_RecvFrom(int s, void *buf, int len, unsigned int flags,
---- ./jdk/src/solaris/native/java/util/TimeZone_md.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/java/util/TimeZone_md.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/java/util/TimeZone_md.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/java/util/TimeZone_md.c Tue May 05 18:07:05 2015 -0700
@@ -52,7 +52,11 @@
#if defined(__linux__) || defined(_ALLBSD_SOURCE)
@@ -12829,8 +12829,8 @@
}
#endif
-
---- ./jdk/src/solaris/native/sun/awt/awt_Font.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/awt/awt_Font.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/awt/awt_Font.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/awt/awt_Font.c Tue May 05 18:07:05 2015 -0700
@@ -255,7 +255,7 @@
if (strcmp(style, "regular") == 0) {
altstyle = "roman";
@@ -12840,8 +12840,8 @@
if (!strcmp(family, "lucidasans")) {
family = "lucida";
}
---- ./jdk/src/solaris/native/sun/awt/awt_GraphicsEnv.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/awt/awt_GraphicsEnv.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/awt/awt_GraphicsEnv.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/awt/awt_GraphicsEnv.c Tue May 05 18:07:05 2015 -0700
@@ -120,7 +120,7 @@
*/
@@ -12926,8 +12926,8 @@
#endif /* HEADLESS */
return point;
}
---- ./jdk/src/solaris/native/sun/awt/awt_InputMethod.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/awt/awt_InputMethod.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/awt/awt_InputMethod.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/awt/awt_InputMethod.c Tue May 05 18:07:05 2015 -0700
@@ -52,7 +52,7 @@
XIMPreeditDrawCallbackStruct *);
static void PreeditCaretCallback(XIC, XPointer,
@@ -13147,8 +13147,8 @@
AWT_LOCK();
adjustStatusWindow(window);
AWT_UNLOCK();
---- ./jdk/src/solaris/native/sun/awt/awt_Robot.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/awt/awt_Robot.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/awt/awt_Robot.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/awt/awt_Robot.c Tue May 05 18:07:05 2015 -0700
@@ -45,7 +45,7 @@
#include "wsutils.h"
#include "list.h"
@@ -13158,8 +13158,8 @@
#include <sys/socket.h>
#endif
---- ./jdk/src/solaris/native/sun/awt/extutil.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/awt/extutil.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/awt/extutil.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/awt/extutil.h Tue May 05 18:07:05 2015 -0700
@@ -58,7 +58,7 @@
*/
/* $XFree86: xc/include/extensions/extutil.h,v 1.5 2001/01/17 17:53:20 dawes Exp $ */
@@ -13175,8 +13175,8 @@
-#endif /* __linux__ || MACOSX */
+#endif /* __linux__ || _ALLBSD_SOURCE */
---- ./jdk/src/solaris/native/sun/awt/fontpath.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/awt/fontpath.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/awt/fontpath.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/awt/fontpath.c Tue May 05 18:07:05 2015 -0700
@@ -23,9 +23,9 @@
* questions.
*/
@@ -13265,8 +13265,8 @@
&& (strcmp((char*)fontformat, "Type 1") != 0)
#endif
) {
---- ./jdk/src/solaris/native/sun/java2d/j2d_md.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/java2d/j2d_md.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/java2d/j2d_md.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/java2d/j2d_md.h Tue May 05 18:07:05 2015 -0700
@@ -28,11 +28,11 @@
#include <sys/types.h>
@@ -13282,8 +13282,8 @@
typedef unsigned char jubyte;
typedef unsigned short jushort;
---- ./jdk/src/solaris/native/sun/java2d/loops/mlib_ImageZoom_NN.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/java2d/loops/mlib_ImageZoom_NN.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/java2d/loops/mlib_ImageZoom_NN.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/java2d/loops/mlib_ImageZoom_NN.c Tue May 05 18:07:05 2015 -0700
@@ -63,9 +63,6 @@
* MLIB_EDGE_SRC_PADDED
*/
@@ -13388,8 +13388,8 @@
LOGIC(da[0], dtmp, dtmp1, |);
}
else { /* aligned */
---- ./jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/java2d/loops/vis_FuncArray.c Tue May 05 18:07:05 2015 -0700
@@ -804,7 +804,7 @@
static int initialized;
static int usevis = JNI_TRUE;
@@ -13399,8 +13399,8 @@
# define ULTRA_CHIP "sparc64"
#else
# define ULTRA_CHIP "sun4u"
---- ./jdk/src/solaris/native/sun/management/OperatingSystemImpl.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/management/OperatingSystemImpl.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/management/OperatingSystemImpl.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/management/OperatingSystemImpl.c Tue May 05 18:07:05 2015 -0700
@@ -56,6 +56,9 @@
#include <limits.h>
#include <stdlib.h>
@@ -13555,8 +13555,8 @@
return -1;
}
---- ./jdk/src/solaris/native/sun/nio/ch/sctp/Sctp.h Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/nio/ch/sctp/Sctp.h Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/nio/ch/sctp/Sctp.h Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/nio/ch/sctp/Sctp.h Tue May 05 18:07:05 2015 -0700
@@ -67,7 +67,7 @@
@@ -13605,8 +13605,8 @@
jboolean loadSocketExtensionFuncs(JNIEnv* env);
#endif /* !SUN_NIO_CH_SCTP_H */
---- ./jdk/src/solaris/native/sun/nio/ch/sctp/SctpNet.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/nio/ch/sctp/SctpNet.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/nio/ch/sctp/SctpNet.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/nio/ch/sctp/SctpNet.c Tue May 05 18:07:05 2015 -0700
@@ -58,6 +58,7 @@
*/
jboolean loadSocketExtensionFuncs
@@ -13623,8 +13623,8 @@
funcsLoaded = JNI_TRUE;
return JNI_TRUE;
---- ./jdk/src/solaris/native/sun/nio/fs/MagicFileTypeDetector.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/nio/fs/MagicFileTypeDetector.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/nio/fs/MagicFileTypeDetector.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/nio/fs/MagicFileTypeDetector.c Tue May 05 18:07:05 2015 -0700
@@ -31,6 +31,12 @@
#include <dlfcn.h>
#include <string.h>
@@ -13647,8 +13647,8 @@
if (magic_handle == NULL) {
return JNI_FALSE;
}
---- ./jdk/src/solaris/native/sun/tools/attach/BsdVirtualMachine.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/tools/attach/BsdVirtualMachine.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/tools/attach/BsdVirtualMachine.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/tools/attach/BsdVirtualMachine.c Tue May 05 18:07:05 2015 -0700
@@ -37,7 +37,9 @@
#include <sys/types.h>
#include <sys/socket.h>
@@ -13659,8 +13659,8 @@
#include <sys/un.h>
#include <fcntl.h>
---- ./jdk/src/solaris/native/sun/xawt/XWindow.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/solaris/native/sun/xawt/XWindow.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/solaris/native/sun/xawt/XWindow.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/solaris/native/sun/xawt/XWindow.c Tue May 05 18:07:05 2015 -0700
@@ -886,7 +886,7 @@
{
KeySym originalKeysym = *keysym;
@@ -13670,8 +13670,8 @@
/* The following code on Linux will cause the keypad keys
* not to echo on JTextField when the NumLock is on. The
* keysyms will be 0, because the last parameter 2 is not defined.
---- ./jdk/src/windows/native/com/sun/media/sound/PLATFORM_API_WinOS_DirectSound.cpp Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/src/windows/native/com/sun/media/sound/PLATFORM_API_WinOS_DirectSound.cpp Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/src/windows/native/com/sun/media/sound/PLATFORM_API_WinOS_DirectSound.cpp Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/src/windows/native/com/sun/media/sound/PLATFORM_API_WinOS_DirectSound.cpp Tue May 05 18:07:05 2015 -0700
@@ -308,7 +308,7 @@
DAUDIO_PCM,
(bitsArray[bitIndex]==8)?FALSE:TRUE, /* signed */
diff --git a/java/openjdk8/files/patch-bsd-test b/java/openjdk8/files/patch-bsd-test
index b973833664b6..3b0cc2632014 100644
--- a/java/openjdk8/files/patch-bsd-test
+++ b/java/openjdk8/files/patch-bsd-test
@@ -1,5 +1,5 @@
---- ./hotspot/test/compiler/5091921/Test7005594.sh Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/test/compiler/5091921/Test7005594.sh Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/test/compiler/5091921/Test7005594.sh Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/test/compiler/5091921/Test7005594.sh Tue May 05 18:06:56 2015 -0700
@@ -60,6 +60,15 @@
# Windows/MKS
MEM=`"$ROOTDIR/mksnt/sysinf" memory -v | grep "Total Physical Memory: " | sed 's/Total Physical Memory: *//g'`
@@ -16,8 +16,8 @@
else
echo "Unable to determine amount of physical memory on the machine"
fi
---- ./hotspot/test/compiler/6894807/Test6894807.sh Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/test/compiler/6894807/Test6894807.sh Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/test/compiler/6894807/Test6894807.sh Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/test/compiler/6894807/Test6894807.sh Tue May 05 18:06:56 2015 -0700
@@ -21,7 +21,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -27,8 +27,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./hotspot/test/runtime/7110720/Test7110720.sh Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/test/runtime/7110720/Test7110720.sh Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/test/runtime/7110720/Test7110720.sh Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/test/runtime/7110720/Test7110720.sh Tue May 05 18:06:56 2015 -0700
@@ -28,7 +28,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -38,8 +38,8 @@
FS="/"
RM=/bin/rm
CP=/bin/cp
---- ./hotspot/test/runtime/XCheckJniJsig/XCheckJSig.java Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/test/runtime/XCheckJniJsig/XCheckJSig.java Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/test/runtime/XCheckJniJsig/XCheckJSig.java Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/test/runtime/XCheckJniJsig/XCheckJSig.java Tue May 05 18:06:56 2015 -0700
@@ -37,8 +37,8 @@
public static void main(String args[]) throws Throwable {
@@ -51,8 +51,8 @@
return;
}
---- ./hotspot/test/test_env.sh Fri Jan 30 15:14:31 2015 -0800
-+++ ./hotspot/test/test_env.sh Sat Mar 14 16:41:08 2015 -0700
+--- ./hotspot/test/test_env.sh Mon Mar 16 11:19:42 2015 -0700
++++ ./hotspot/test/test_env.sh Tue May 05 18:06:56 2015 -0700
@@ -53,7 +53,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -62,8 +62,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/com/sun/corba/5036554/TestCorbaBug.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/com/sun/corba/5036554/TestCorbaBug.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/com/sun/corba/5036554/TestCorbaBug.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/com/sun/corba/5036554/TestCorbaBug.sh Tue May 05 18:07:05 2015 -0700
@@ -48,7 +48,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -73,8 +73,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/com/sun/corba/cachedSocket/7056731.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/com/sun/corba/cachedSocket/7056731.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/com/sun/corba/cachedSocket/7056731.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/com/sun/corba/cachedSocket/7056731.sh Tue May 05 18:07:05 2015 -0700
@@ -31,7 +31,7 @@
OS=`uname -s`
@@ -84,8 +84,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/com/sun/jdi/ImmutableResourceTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/com/sun/jdi/ImmutableResourceTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/com/sun/jdi/ImmutableResourceTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/com/sun/jdi/ImmutableResourceTest.sh Tue May 05 18:07:05 2015 -0700
@@ -56,7 +56,7 @@
OS=`uname -s`
@@ -95,8 +95,8 @@
PATHSEP=":"
;;
---- ./jdk/test/com/sun/jdi/JITDebug.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/com/sun/jdi/JITDebug.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/com/sun/jdi/JITDebug.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/com/sun/jdi/JITDebug.sh Tue May 05 18:07:05 2015 -0700
@@ -63,7 +63,7 @@
OS=`uname -s`
export TRANSPORT_METHOD
@@ -106,8 +106,8 @@
PATHSEP=":"
TRANSPORT_METHOD=dt_socket
;;
---- ./jdk/test/com/sun/jdi/PrivateTransportTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/com/sun/jdi/PrivateTransportTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/com/sun/jdi/PrivateTransportTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/com/sun/jdi/PrivateTransportTest.sh Tue May 05 18:07:05 2015 -0700
@@ -106,7 +106,7 @@
xx=`find ${jreloc}/lib -name libdt_socket.so`
libloc=`dirname ${xx}`
@@ -117,8 +117,8 @@
libloc=${jreloc}/lib
;;
Windows*)
---- ./jdk/test/com/sun/jdi/ShellScaffold.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/com/sun/jdi/ShellScaffold.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/com/sun/jdi/ShellScaffold.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/com/sun/jdi/ShellScaffold.sh Tue May 05 18:07:05 2015 -0700
@@ -295,7 +295,7 @@
psCmd=ps
jstack=jstack.exe
@@ -128,8 +128,8 @@
transport=dt_socket
address=
devnull=/dev/null
---- ./jdk/test/com/sun/jdi/connect/spi/JdiLoadedByCustomLoader.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/com/sun/jdi/connect/spi/JdiLoadedByCustomLoader.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/com/sun/jdi/connect/spi/JdiLoadedByCustomLoader.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/com/sun/jdi/connect/spi/JdiLoadedByCustomLoader.sh Tue May 05 18:07:05 2015 -0700
@@ -45,7 +45,7 @@
OS=`uname -s`
@@ -139,8 +139,8 @@
PS=":"
;;
Windows* | CYGWIN*)
---- ./jdk/test/java/awt/JAWT/JAWT.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/awt/JAWT/JAWT.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/awt/JAWT/JAWT.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/awt/JAWT/JAWT.sh Tue May 05 18:07:05 2015 -0700
@@ -62,6 +62,23 @@
MAKE="make"
LD_LIBRARY_PATH="."
@@ -174,8 +174,8 @@
exit 0;
;;
* )
---- ./jdk/test/java/awt/Toolkit/AutoShutdown/ShowExitTest/ShowExitTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/awt/Toolkit/AutoShutdown/ShowExitTest/ShowExitTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/awt/Toolkit/AutoShutdown/ShowExitTest/ShowExitTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/awt/Toolkit/AutoShutdown/ShowExitTest/ShowExitTest.sh Tue May 05 18:07:05 2015 -0700
@@ -86,6 +86,14 @@
TMP="/tmp"
;;
@@ -191,8 +191,8 @@
Windows* )
VAR="A different value for Win32"
DEFAULT_JDK="C:/Program Files/Java/jdk1.8.0"
---- ./jdk/test/java/awt/Toolkit/Headless/WrappedToolkitTest/WrappedToolkitTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/awt/Toolkit/Headless/WrappedToolkitTest/WrappedToolkitTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/awt/Toolkit/Headless/WrappedToolkitTest/WrappedToolkitTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/awt/Toolkit/Headless/WrappedToolkitTest/WrappedToolkitTest.sh Tue May 05 18:07:05 2015 -0700
@@ -59,7 +59,7 @@
# Checking for proper OS
OS=`uname -s`
@@ -202,8 +202,8 @@
FILESEP="/"
;;
---- ./jdk/test/java/awt/appletviewer/IOExceptionIfEncodedURLTest/IOExceptionIfEncodedURLTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/awt/appletviewer/IOExceptionIfEncodedURLTest/IOExceptionIfEncodedURLTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/awt/appletviewer/IOExceptionIfEncodedURLTest/IOExceptionIfEncodedURLTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/awt/appletviewer/IOExceptionIfEncodedURLTest/IOExceptionIfEncodedURLTest.sh Tue May 05 18:07:05 2015 -0700
@@ -119,6 +119,14 @@
TMP="/tmp"
;;
@@ -219,8 +219,8 @@
Windows* )
VAR="A different value for Win32"
DEFAULT_JDK="C:/Program Files/Java/jdk1.8.0"
---- ./jdk/test/java/io/File/GetXSpace.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/io/File/GetXSpace.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/io/File/GetXSpace.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/io/File/GetXSpace.java Tue May 05 18:07:05 2015 -0700
@@ -51,7 +51,7 @@
private static final String dfFormat;
static {
@@ -230,8 +230,8 @@
// FileSystem Total Used Available Use% MountedOn
dfFormat = "([^\\s]+)\\s+(\\d+)\\s+\\d+\\s+(\\d+)\\s+\\d+%\\s+([^\\s]+)";
} else if (name.startsWith("Windows")) {
---- ./jdk/test/java/io/File/GetXSpace.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/io/File/GetXSpace.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/io/File/GetXSpace.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/io/File/GetXSpace.sh Tue May 05 18:07:05 2015 -0700
@@ -26,7 +26,7 @@
# set platform-dependent variable
OS=`uname -s`
@@ -241,8 +241,8 @@
Windows_98 ) return ;;
Windows* ) SID=`sid`; TMP="c:/temp" ;;
* )
---- ./jdk/test/java/io/Serializable/evolution/RenamePackage/run.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/io/Serializable/evolution/RenamePackage/run.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/io/Serializable/evolution/RenamePackage/run.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/io/Serializable/evolution/RenamePackage/run.sh Tue May 05 18:07:05 2015 -0700
@@ -45,7 +45,7 @@
# Need to determine the classpath separator and filepath separator based on the
# operating system.
@@ -252,8 +252,8 @@
PS=":" ;;
Windows* | CYGWIN* )
PS=";" ;;
---- ./jdk/test/java/io/Serializable/serialver/classpath/run.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/io/Serializable/serialver/classpath/run.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/io/Serializable/serialver/classpath/run.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/io/Serializable/serialver/classpath/run.sh Tue May 05 18:07:05 2015 -0700
@@ -47,7 +47,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -263,8 +263,8 @@
PS=":" ;;
Windows* | CYGWIN* )
PS=";" ;;
---- ./jdk/test/java/io/Serializable/serialver/nested/run.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/io/Serializable/serialver/nested/run.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/io/Serializable/serialver/nested/run.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/io/Serializable/serialver/nested/run.sh Tue May 05 18:07:05 2015 -0700
@@ -47,7 +47,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -274,8 +274,8 @@
PS=":" ;;
Windows* | CYGWIN* )
PS=";" ;;
---- ./jdk/test/java/lang/ClassLoader/Assert.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/ClassLoader/Assert.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/ClassLoader/Assert.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/ClassLoader/Assert.sh Tue May 05 18:07:05 2015 -0700
@@ -25,7 +25,7 @@
OS=`uname -s`
@@ -285,8 +285,8 @@
FS="/"
CHMOD="${FS}bin${FS}chmod"
;;
---- ./jdk/test/java/lang/ClassLoader/deadlock/TestCrossDelegate.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/ClassLoader/deadlock/TestCrossDelegate.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/ClassLoader/deadlock/TestCrossDelegate.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/ClassLoader/deadlock/TestCrossDelegate.sh Tue May 05 18:07:05 2015 -0700
@@ -55,7 +55,7 @@
Linux )
FS="/"
@@ -296,8 +296,8 @@
FS="/"
;;
AIX )
---- ./jdk/test/java/lang/ClassLoader/deadlock/TestOneWayDelegate.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/ClassLoader/deadlock/TestOneWayDelegate.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/ClassLoader/deadlock/TestOneWayDelegate.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/ClassLoader/deadlock/TestOneWayDelegate.sh Tue May 05 18:07:05 2015 -0700
@@ -60,7 +60,7 @@
Linux )
FS="/"
@@ -307,8 +307,8 @@
FS="/"
;;
AIX )
---- ./jdk/test/java/lang/ProcessBuilder/DestroyTest.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/ProcessBuilder/DestroyTest.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/ProcessBuilder/DestroyTest.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/ProcessBuilder/DestroyTest.java Tue May 05 18:07:05 2015 -0700
@@ -148,6 +148,9 @@
} else if (osName.startsWith("Linux") == true) {
return new UnixTest(
@@ -319,8 +319,8 @@
} else if (osName.startsWith("Mac OS")) {
return new MacTest(
File.createTempFile("ProcessTrap-", ".sh",null));
---- ./jdk/test/java/lang/ProcessBuilder/Zombies.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/ProcessBuilder/Zombies.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/ProcessBuilder/Zombies.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/ProcessBuilder/Zombies.java Tue May 05 18:07:05 2015 -0700
@@ -34,7 +34,7 @@
static final String os = System.getProperty("os.name");
@@ -330,8 +330,8 @@
"/usr/bin/true" : "/bin/true";
public static void main(String[] args) throws Throwable {
---- ./jdk/test/java/lang/StringCoding/CheckEncodings.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/StringCoding/CheckEncodings.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/StringCoding/CheckEncodings.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/StringCoding/CheckEncodings.sh Tue May 05 18:07:05 2015 -0700
@@ -30,7 +30,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -341,8 +341,8 @@
Windows* | CYGWIN* )
echo "Passed"; exit 0 ;;
* ) echo "Unrecognized system!" ; exit 1 ;;
---- ./jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh Tue May 05 18:07:05 2015 -0700
@@ -48,7 +48,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -352,8 +352,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/java/lang/instrument/MakeJAR2.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/instrument/MakeJAR2.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/instrument/MakeJAR2.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/instrument/MakeJAR2.sh Tue May 05 18:07:05 2015 -0700
@@ -55,7 +55,7 @@
OS=`uname -s`
@@ -363,8 +363,8 @@
PATHSEP=":"
;;
---- ./jdk/test/java/lang/instrument/appendToClassLoaderSearch/CommonSetup.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/instrument/appendToClassLoaderSearch/CommonSetup.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/instrument/appendToClassLoaderSearch/CommonSetup.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/instrument/appendToClassLoaderSearch/CommonSetup.sh Tue May 05 18:07:05 2015 -0700
@@ -43,7 +43,7 @@
PS=":"
FS="/"
@@ -374,8 +374,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/lang/management/OperatingSystemMXBean/GetSystemLoadAverage.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/management/OperatingSystemMXBean/GetSystemLoadAverage.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/management/OperatingSystemMXBean/GetSystemLoadAverage.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/management/OperatingSystemMXBean/GetSystemLoadAverage.java Tue May 05 18:07:05 2015 -0700
@@ -79,8 +79,10 @@
System.out.println("Test passed.");
}
@@ -397,8 +397,8 @@
? output.split(" ")
: output.split(",");
double expected = Double.parseDouble(lavg[0]);
---- ./jdk/test/java/lang/management/OperatingSystemMXBean/TestSystemLoadAvg.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/lang/management/OperatingSystemMXBean/TestSystemLoadAvg.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/lang/management/OperatingSystemMXBean/TestSystemLoadAvg.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/lang/management/OperatingSystemMXBean/TestSystemLoadAvg.sh Tue May 05 18:07:05 2015 -0700
@@ -61,7 +61,7 @@
while true; do
echo "Run $i: TestSystemLoadAvg"
@@ -408,8 +408,8 @@
runOne GetSystemLoadAverage
;;
* )
---- ./jdk/test/java/net/Authenticator/B4933582.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/Authenticator/B4933582.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/Authenticator/B4933582.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/Authenticator/B4933582.sh Tue May 05 18:07:05 2015 -0700
@@ -26,7 +26,7 @@
OS=`uname -s`
@@ -419,8 +419,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/net/DatagramSocket/Send12k.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/DatagramSocket/Send12k.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/DatagramSocket/Send12k.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/DatagramSocket/Send12k.java Tue May 05 18:07:05 2015 -0700
@@ -36,9 +36,10 @@
public static void main(String args[]) throws Exception {
@@ -434,8 +434,8 @@
SEND_SIZE = 16 * 576;
} else {
SEND_SIZE = 16 * 1024;
---- ./jdk/test/java/net/DatagramSocket/SendDatagramToBadAddress.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/DatagramSocket/SendDatagramToBadAddress.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/DatagramSocket/SendDatagramToBadAddress.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/DatagramSocket/SendDatagramToBadAddress.java Tue May 05 18:07:05 2015 -0700
@@ -45,6 +45,8 @@
return (true);
if (p.getProperty ("os.name").equals ("Linux"))
@@ -445,8 +445,8 @@
if (p.getProperty ("os.name").startsWith ("Mac OS"))
return (true);
// Check for specific Solaris version from here
---- ./jdk/test/java/net/DatagramSocket/SetDatagramSocketImplFactory/ADatagramSocket.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/DatagramSocket/SetDatagramSocketImplFactory/ADatagramSocket.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/DatagramSocket/SetDatagramSocketImplFactory/ADatagramSocket.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/DatagramSocket/SetDatagramSocketImplFactory/ADatagramSocket.sh Tue May 05 18:07:05 2015 -0700
@@ -27,11 +27,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -460,8 +460,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/java/net/Socket/OldSocketImpl.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/Socket/OldSocketImpl.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/Socket/OldSocketImpl.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/Socket/OldSocketImpl.sh Tue May 05 18:07:05 2015 -0700
@@ -28,7 +28,7 @@
OS=`uname -s`
@@ -471,8 +471,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/net/URL/B5086147.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/URL/B5086147.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/URL/B5086147.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/URL/B5086147.sh Tue May 05 18:07:05 2015 -0700
@@ -26,7 +26,7 @@
OS=`uname -s`
@@ -482,8 +482,8 @@
exit 0
;;
CYGWIN* )
---- ./jdk/test/java/net/URLClassLoader/B5077773.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/URLClassLoader/B5077773.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/URLClassLoader/B5077773.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/URLClassLoader/B5077773.sh Tue May 05 18:07:05 2015 -0700
@@ -34,11 +34,7 @@
OS=`uname -s`
@@ -497,8 +497,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/net/URLClassLoader/sealing/checksealed.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/URLClassLoader/sealing/checksealed.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/URLClassLoader/sealing/checksealed.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/URLClassLoader/sealing/checksealed.sh Tue May 05 18:07:05 2015 -0700
@@ -27,11 +27,7 @@
OS=`uname -s`
@@ -512,8 +512,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/net/URLConnection/6212146/test.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/net/URLConnection/6212146/test.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/net/URLConnection/6212146/test.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/net/URLConnection/6212146/test.sh Tue May 05 18:07:05 2015 -0700
@@ -33,11 +33,7 @@
OS=`uname -s`
@@ -527,8 +527,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/nio/channels/FileChannel/Transfer.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/nio/channels/FileChannel/Transfer.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/nio/channels/FileChannel/Transfer.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/nio/channels/FileChannel/Transfer.java Tue May 05 18:07:05 2015 -0700
@@ -228,7 +228,7 @@
// Windows and Linux can't handle the really large file sizes for a
// truncate or a positional write required by the test for 4563125
@@ -538,8 +538,8 @@
return;
File source = File.createTempFile("blah", null);
source.deleteOnExit();
---- ./jdk/test/java/nio/channels/spi/SelectorProvider/inheritedChannel/Launcher.c Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/nio/channels/spi/SelectorProvider/inheritedChannel/Launcher.c Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/nio/channels/spi/SelectorProvider/inheritedChannel/Launcher.c Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/nio/channels/spi/SelectorProvider/inheritedChannel/Launcher.c Tue May 05 18:07:05 2015 -0700
@@ -17,6 +17,12 @@
#include "Launcher.h"
@@ -562,8 +562,8 @@
_exit(-1);
}
---- ./jdk/test/java/nio/charset/coders/CheckSJISMappingProp.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/nio/charset/coders/CheckSJISMappingProp.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/nio/charset/coders/CheckSJISMappingProp.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/nio/charset/coders/CheckSJISMappingProp.sh Tue May 05 18:07:05 2015 -0700
@@ -34,7 +34,7 @@
OS=`uname -s`
@@ -573,8 +573,8 @@
# Skip locale test for Windows
Windows* | CYGWIN* )
echo "Passed"; exit 0 ;;
---- ./jdk/test/java/nio/charset/spi/basic.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/nio/charset/spi/basic.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/nio/charset/spi/basic.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/nio/charset/spi/basic.sh Tue May 05 18:07:05 2015 -0700
@@ -48,7 +48,7 @@
DIR=`pwd`
@@ -584,8 +584,8 @@
Windows* ) CPS=';' ;;
CYGWIN* )
DIR=`/usr/bin/cygpath -a -s -m $DIR`
---- ./jdk/test/java/nio/file/FileSystem/Basic.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/nio/file/FileSystem/Basic.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/nio/file/FileSystem/Basic.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/nio/file/FileSystem/Basic.java Tue May 05 18:07:05 2015 -0700
@@ -76,7 +76,7 @@
checkSupported(fs, "posix", "unix", "owner", "acl", "user");
if (os.equals("Linux"))
@@ -595,8 +595,8 @@
checkSupported(fs, "posix", "unix", "owner");
if (os.equals("Windows"))
checkSupported(fs, "owner", "dos", "acl", "user");
---- ./jdk/test/java/nio/file/Files/CopyAndMove.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/nio/file/Files/CopyAndMove.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/nio/file/Files/CopyAndMove.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/nio/file/Files/CopyAndMove.java Tue May 05 18:07:05 2015 -0700
@@ -651,7 +651,7 @@
// check POSIX attributes are copied
@@ -615,8 +615,8 @@
boolean isDirectory = isDirectory(file, NOFOLLOW_LINKS);
if (isUnix) {
---- ./jdk/test/java/rmi/activation/Activatable/extLoadedImpl/ext.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/rmi/activation/Activatable/extLoadedImpl/ext.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/rmi/activation/Activatable/extLoadedImpl/ext.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/rmi/activation/Activatable/extLoadedImpl/ext.sh Tue May 05 18:07:05 2015 -0700
@@ -33,7 +33,7 @@
OS=`uname -s`
@@ -626,8 +626,8 @@
PS=":"
;;
Windows* | CYGWIN* )
---- ./jdk/test/java/rmi/registry/readTest/readTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/rmi/registry/readTest/readTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/rmi/registry/readTest/readTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/rmi/registry/readTest/readTest.sh Tue May 05 18:07:05 2015 -0700
@@ -34,7 +34,7 @@
REGARGS=""
@@ -637,8 +637,8 @@
PS=":"
FS="/"
CHMOD="${FS}bin${FS}chmod"
---- ./jdk/test/java/security/Security/ClassLoaderDeadlock/ClassLoaderDeadlock.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/security/Security/ClassLoaderDeadlock/ClassLoaderDeadlock.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/security/Security/ClassLoaderDeadlock/ClassLoaderDeadlock.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/security/Security/ClassLoaderDeadlock/ClassLoaderDeadlock.sh Tue May 05 18:07:05 2015 -0700
@@ -58,7 +58,7 @@
PATHSEP=":"
FILESEP="/"
@@ -648,8 +648,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock.sh Tue May 05 18:07:05 2015 -0700
@@ -42,7 +42,7 @@
PATHSEP=":"
FILESEP="/"
@@ -659,8 +659,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock2.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock2.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock2.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/security/Security/ClassLoaderDeadlock/Deadlock2.sh Tue May 05 18:07:05 2015 -0700
@@ -66,7 +66,7 @@
PATHSEP=";"
FILESEP="/"
@@ -670,8 +670,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/java/security/Security/signedfirst/Dyn.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/security/Security/signedfirst/Dyn.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/security/Security/signedfirst/Dyn.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/security/Security/signedfirst/Dyn.sh Tue May 05 18:07:05 2015 -0700
@@ -58,7 +58,7 @@
PATHSEP=":"
FILESEP="/"
@@ -681,8 +681,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/java/security/Security/signedfirst/Static.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/security/Security/signedfirst/Static.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/security/Security/signedfirst/Static.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/security/Security/signedfirst/Static.sh Tue May 05 18:07:05 2015 -0700
@@ -58,7 +58,7 @@
PATHSEP=":"
FILESEP="/"
@@ -692,8 +692,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/java/util/Currency/PropertiesTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/util/Currency/PropertiesTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/util/Currency/PropertiesTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/util/Currency/PropertiesTest.sh Tue May 05 18:07:05 2015 -0700
@@ -52,7 +52,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -703,8 +703,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/util/PluggableLocale/ExecTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/util/PluggableLocale/ExecTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/util/PluggableLocale/ExecTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/util/PluggableLocale/ExecTest.sh Tue May 05 18:07:05 2015 -0700
@@ -62,7 +62,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -714,8 +714,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/java/util/ResourceBundle/Bug6299235Test.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/util/ResourceBundle/Bug6299235Test.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/util/ResourceBundle/Bug6299235Test.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/util/ResourceBundle/Bug6299235Test.sh Tue May 05 18:07:05 2015 -0700
@@ -31,7 +31,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -725,8 +725,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/java/util/ServiceLoader/basic.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/util/ServiceLoader/basic.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/util/ServiceLoader/basic.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/util/ServiceLoader/basic.sh Tue May 05 18:07:05 2015 -0700
@@ -43,9 +43,7 @@
OS=`uname -s`
@@ -738,8 +738,8 @@
SEP=':' ;;
* )
SEP='\;' ;;
---- ./jdk/test/java/util/prefs/CheckUserPrefsStorage.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/java/util/prefs/CheckUserPrefsStorage.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/java/util/prefs/CheckUserPrefsStorage.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/java/util/prefs/CheckUserPrefsStorage.sh Tue May 05 18:07:05 2015 -0700
@@ -31,7 +31,7 @@
OS=`uname -s`
@@ -749,8 +749,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/javax/crypto/SecretKeyFactory/FailOverTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/javax/crypto/SecretKeyFactory/FailOverTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/javax/crypto/SecretKeyFactory/FailOverTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/javax/crypto/SecretKeyFactory/FailOverTest.sh Tue May 05 18:07:05 2015 -0700
@@ -56,7 +56,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -760,8 +760,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatTest.sh Tue May 05 18:07:05 2015 -0700
@@ -89,7 +89,7 @@
FILESEP="/"
;;
@@ -771,8 +771,8 @@
VAR="A different value for Linux"
DEFAULT_JDK=/none
#DEFAULT_JDK=/usr/local/java/jdk1.4/linux-i386
---- ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatThreadTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatThreadTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatThreadTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/javax/imageio/metadata/IIOMetadataFormat/runMetadataFormatThreadTest.sh Tue May 05 18:07:05 2015 -0700
@@ -90,7 +90,7 @@
FILESEP="/"
;;
@@ -782,8 +782,8 @@
VAR="A different value for Linux"
DEFAULT_JDK=/none
#DEFAULT_JDK=/usr/local/java/jdk1.4/linux-i386
---- ./jdk/test/javax/imageio/stream/StreamCloserLeak/run_test.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/javax/imageio/stream/StreamCloserLeak/run_test.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/javax/imageio/stream/StreamCloserLeak/run_test.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/javax/imageio/stream/StreamCloserLeak/run_test.sh Tue May 05 18:07:05 2015 -0700
@@ -108,6 +108,14 @@
TMP="/tmp"
;;
@@ -799,8 +799,8 @@
Windows* )
VAR="A different value for Win32"
DEFAULT_JDK="C:/Program Files/Java/jdk1.8.0"
---- ./jdk/test/javax/script/CommonSetup.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/javax/script/CommonSetup.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/javax/script/CommonSetup.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/javax/script/CommonSetup.sh Tue May 05 18:07:05 2015 -0700
@@ -36,7 +36,7 @@
OS=`uname -s`
@@ -810,8 +810,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/javax/security/auth/Subject/doAs/Test.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/javax/security/auth/Subject/doAs/Test.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/javax/security/auth/Subject/doAs/Test.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/javax/security/auth/Subject/doAs/Test.sh Tue May 05 18:07:05 2015 -0700
@@ -43,7 +43,7 @@
FS="/"
RM="/bin/rm -f"
@@ -821,8 +821,8 @@
PS=":"
FS="/"
RM="/bin/rm -f"
---- ./jdk/test/lib/security/java.policy/Ext_AllPolicy.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/lib/security/java.policy/Ext_AllPolicy.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/lib/security/java.policy/Ext_AllPolicy.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/lib/security/java.policy/Ext_AllPolicy.sh Tue May 05 18:07:05 2015 -0700
@@ -53,7 +53,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -832,8 +832,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/lib/testlibrary/jdk/testlibrary/Platform.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/lib/testlibrary/jdk/testlibrary/Platform.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/lib/testlibrary/jdk/testlibrary/Platform.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/lib/testlibrary/jdk/testlibrary/Platform.java Tue May 05 18:07:05 2015 -0700
@@ -53,8 +53,13 @@
return isOs("linux");
}
@@ -849,8 +849,8 @@
}
public static String getOsName() {
---- ./jdk/test/sun/awt/dnd/8024061/bug8024061.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/awt/dnd/8024061/bug8024061.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/awt/dnd/8024061/bug8024061.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/awt/dnd/8024061/bug8024061.java Tue May 05 18:07:05 2015 -0700
@@ -107,8 +107,8 @@
public static void main(String[] args) throws AWTException, InvocationTargetException, InterruptedException {
@@ -862,8 +862,8 @@
"skipping!");
return;
}
---- ./jdk/test/sun/management/jmxremote/bootstrap/GeneratePropertyPassword.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/management/jmxremote/bootstrap/GeneratePropertyPassword.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/management/jmxremote/bootstrap/GeneratePropertyPassword.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/management/jmxremote/bootstrap/GeneratePropertyPassword.sh Tue May 05 18:07:05 2015 -0700
@@ -42,7 +42,7 @@
fi
@@ -873,8 +873,8 @@
PATHSEP=":"
FILESEP="/"
DFILESEP=$FILESEP
---- ./jdk/test/sun/net/ftp/MarkResetTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/net/ftp/MarkResetTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/net/ftp/MarkResetTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/net/ftp/MarkResetTest.sh Tue May 05 18:07:05 2015 -0700
@@ -28,7 +28,7 @@
OS=`uname -s`
@@ -884,8 +884,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/net/www/http/HttpClient/RetryPost.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/net/www/http/HttpClient/RetryPost.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/net/www/http/HttpClient/RetryPost.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/net/www/http/HttpClient/RetryPost.sh Tue May 05 18:07:05 2015 -0700
@@ -28,7 +28,7 @@
OS=`uname -s`
@@ -895,8 +895,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/net/www/protocol/jar/B5105410.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/net/www/protocol/jar/B5105410.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/net/www/protocol/jar/B5105410.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/net/www/protocol/jar/B5105410.sh Tue May 05 18:07:05 2015 -0700
@@ -31,7 +31,7 @@
OS=`uname -s`
@@ -906,8 +906,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/net/www/protocol/jar/jarbug/run.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/net/www/protocol/jar/jarbug/run.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/net/www/protocol/jar/jarbug/run.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/net/www/protocol/jar/jarbug/run.sh Tue May 05 18:07:05 2015 -0700
@@ -31,7 +31,7 @@
OS=`uname -s`
@@ -917,8 +917,8 @@
PS=":"
FS="/"
CHMOD="${FS}bin${FS}chmod"
---- ./jdk/test/sun/nio/ch/SelProvider.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/nio/ch/SelProvider.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/nio/ch/SelProvider.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/nio/ch/SelProvider.java Tue May 05 18:07:05 2015 -0700
@@ -39,7 +39,7 @@
expected = "sun.nio.ch.DevPollSelectorProvider";
} else if ("Linux".equals(osname)) {
@@ -928,8 +928,8 @@
expected = "sun.nio.ch.KQueueSelectorProvider";
} else {
return;
---- ./jdk/test/sun/security/krb5/runNameEquals.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/krb5/runNameEquals.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/krb5/runNameEquals.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/krb5/runNameEquals.sh Tue May 05 18:07:05 2015 -0700
@@ -52,7 +52,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -939,8 +939,8 @@
PATHSEP=":"
FILESEP="/"
NATIVE=true
---- ./jdk/test/sun/security/mscapi/ShortRSAKey1024.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/mscapi/ShortRSAKey1024.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/mscapi/ShortRSAKey1024.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/mscapi/ShortRSAKey1024.sh Tue May 05 18:07:05 2015 -0700
@@ -49,7 +49,7 @@
OS=`uname -s`
@@ -950,8 +950,8 @@
FS="/"
;;
Windows_* )
---- ./jdk/test/sun/security/pkcs11/Provider/ConfigQuotedString.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/pkcs11/Provider/ConfigQuotedString.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/pkcs11/Provider/ConfigQuotedString.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/pkcs11/Provider/ConfigQuotedString.sh Tue May 05 18:07:05 2015 -0700
@@ -66,7 +66,7 @@
CP="${FS}bin${FS}cp"
CHMOD="${FS}bin${FS}chmod"
@@ -961,8 +961,8 @@
FS="/"
PS=":"
CP="${FS}bin${FS}cp"
---- ./jdk/test/sun/security/pkcs11/Provider/Login.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/pkcs11/Provider/Login.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/pkcs11/Provider/Login.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/pkcs11/Provider/Login.sh Tue May 05 18:07:05 2015 -0700
@@ -67,7 +67,7 @@
CP="${FS}bin${FS}cp"
CHMOD="${FS}bin${FS}chmod"
@@ -972,8 +972,8 @@
FS="/"
PS=":"
CP="${FS}bin${FS}cp"
---- ./jdk/test/sun/security/provider/KeyStore/DKSTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/provider/KeyStore/DKSTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/provider/KeyStore/DKSTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/provider/KeyStore/DKSTest.sh Tue May 05 18:07:05 2015 -0700
@@ -50,7 +50,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -983,8 +983,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/security/provider/PolicyFile/GrantAllPermToExtWhenNoPolicy.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/provider/PolicyFile/GrantAllPermToExtWhenNoPolicy.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/provider/PolicyFile/GrantAllPermToExtWhenNoPolicy.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/provider/PolicyFile/GrantAllPermToExtWhenNoPolicy.sh Tue May 05 18:07:05 2015 -0700
@@ -52,7 +52,7 @@
PATHSEP=":"
FILESEP="/"
@@ -994,8 +994,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/sun/security/provider/PolicyFile/getinstance/getinstance.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/provider/PolicyFile/getinstance/getinstance.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/provider/PolicyFile/getinstance/getinstance.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/provider/PolicyFile/getinstance/getinstance.sh Tue May 05 18:07:05 2015 -0700
@@ -59,7 +59,7 @@
PS=":"
FS="/"
@@ -1005,8 +1005,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/EngineArgs/DebugReportsOneExtraByte.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/EngineArgs/DebugReportsOneExtraByte.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/EngineArgs/DebugReportsOneExtraByte.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/EngineArgs/DebugReportsOneExtraByte.sh Tue May 05 18:07:05 2015 -0700
@@ -33,7 +33,7 @@
OS=`uname -s`
@@ -1016,8 +1016,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLSocketImpl/NotifyHandshakeTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLSocketImpl/NotifyHandshakeTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLSocketImpl/NotifyHandshakeTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLSocketImpl/NotifyHandshakeTest.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
OS=`uname -s`
@@ -1027,8 +1027,8 @@
FILESEP="/"
PATHSEP=":"
;;
---- ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxy.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxy.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxy.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxy.sh Tue May 05 18:07:05 2015 -0700
@@ -32,7 +32,7 @@
HOSTNAME=`uname -n`
OS=`uname -s`
@@ -1038,8 +1038,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxyWithAuth.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxyWithAuth.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxyWithAuth.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/ssl/sun/net/www/protocol/https/HttpsURLConnection/PostThruProxyWithAuth.sh Tue May 05 18:07:05 2015 -0700
@@ -32,7 +32,7 @@
HOSTNAME=`uname -n`
OS=`uname -s`
@@ -1049,8 +1049,8 @@
PS=":"
FS="/"
;;
---- ./jdk/test/sun/security/tools/jarsigner/AlgOptions.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/jarsigner/AlgOptions.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/jarsigner/AlgOptions.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/jarsigner/AlgOptions.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1060,8 +1060,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/jarsigner/PercentSign.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/jarsigner/PercentSign.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/jarsigner/PercentSign.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/jarsigner/PercentSign.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1071,8 +1071,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/jarsigner/diffend.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/jarsigner/diffend.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/jarsigner/diffend.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/jarsigner/diffend.sh Tue May 05 18:07:05 2015 -0700
@@ -47,6 +47,13 @@
FS="/"
CP="${FS}bin${FS}cp -f"
@@ -1087,8 +1087,8 @@
CYGWIN* )
NULL=/dev/null
PS=";"
---- ./jdk/test/sun/security/tools/jarsigner/emptymanifest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/jarsigner/emptymanifest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/jarsigner/emptymanifest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/jarsigner/emptymanifest.sh Tue May 05 18:07:05 2015 -0700
@@ -39,6 +39,11 @@
Windows_* )
FS="\\"
@@ -1101,8 +1101,8 @@
* )
FS="/"
;;
---- ./jdk/test/sun/security/tools/jarsigner/oldsig.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/jarsigner/oldsig.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/jarsigner/oldsig.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/jarsigner/oldsig.sh Tue May 05 18:07:05 2015 -0700
@@ -42,7 +42,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1112,8 +1112,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/keytool/AltProviderPath.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/AltProviderPath.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/AltProviderPath.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/AltProviderPath.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1123,8 +1123,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/keytool/CloneKeyAskPassword.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/CloneKeyAskPassword.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/CloneKeyAskPassword.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/CloneKeyAskPassword.sh Tue May 05 18:07:05 2015 -0700
@@ -55,7 +55,7 @@
PATHSEP=":"
FILESEP="/"
@@ -1134,8 +1134,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/sun/security/tools/keytool/NoExtNPE.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/NoExtNPE.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/NoExtNPE.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/NoExtNPE.sh Tue May 05 18:07:05 2015 -0700
@@ -48,7 +48,7 @@
Linux )
FILESEP="/"
@@ -1145,8 +1145,8 @@
FILESEP="/"
;;
AIX )
---- ./jdk/test/sun/security/tools/keytool/SecretKeyKS.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/SecretKeyKS.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/SecretKeyKS.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/SecretKeyKS.sh Tue May 05 18:07:05 2015 -0700
@@ -45,7 +45,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1156,8 +1156,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/keytool/StandardAlgName.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/StandardAlgName.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/StandardAlgName.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/StandardAlgName.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1167,8 +1167,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/keytool/StorePasswordsByShell.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/StorePasswordsByShell.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/StorePasswordsByShell.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/StorePasswordsByShell.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1178,8 +1178,8 @@
PATHSEP=":"
FILESEP="/"
;;
---- ./jdk/test/sun/security/tools/keytool/i18n.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/i18n.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/i18n.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/i18n.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1189,8 +1189,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/keytool/printssl.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/printssl.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/printssl.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/printssl.sh Tue May 05 18:07:05 2015 -0700
@@ -40,7 +40,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1200,8 +1200,8 @@
FS="/"
;;
CYGWIN* )
---- ./jdk/test/sun/security/tools/keytool/resource.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/resource.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/resource.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/resource.sh Tue May 05 18:07:05 2015 -0700
@@ -43,7 +43,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1211,8 +1211,8 @@
NULL=/dev/null
FS="/"
;;
---- ./jdk/test/sun/security/tools/keytool/standard.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/keytool/standard.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/keytool/standard.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/keytool/standard.sh Tue May 05 18:07:05 2015 -0700
@@ -45,7 +45,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1222,8 +1222,8 @@
FS="/"
;;
Windows_* )
---- ./jdk/test/sun/security/tools/policytool/Alias.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/policytool/Alias.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/policytool/Alias.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/policytool/Alias.sh Tue May 05 18:07:05 2015 -0700
@@ -47,7 +47,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1233,8 +1233,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/policytool/ChangeUI.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/policytool/ChangeUI.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/policytool/ChangeUI.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/policytool/ChangeUI.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1244,8 +1244,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/policytool/OpenPolicy.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/policytool/OpenPolicy.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/policytool/OpenPolicy.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/policytool/OpenPolicy.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1255,8 +1255,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/policytool/SaveAs.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/policytool/SaveAs.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/policytool/SaveAs.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/policytool/SaveAs.sh Tue May 05 18:07:05 2015 -0700
@@ -47,7 +47,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1266,8 +1266,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/policytool/UpdatePermissions.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/policytool/UpdatePermissions.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/policytool/UpdatePermissions.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/policytool/UpdatePermissions.sh Tue May 05 18:07:05 2015 -0700
@@ -47,7 +47,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1277,8 +1277,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/policytool/UsePolicy.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/policytool/UsePolicy.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/policytool/UsePolicy.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/policytool/UsePolicy.sh Tue May 05 18:07:05 2015 -0700
@@ -46,7 +46,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1288,8 +1288,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/security/tools/policytool/i18n.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/security/tools/policytool/i18n.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/security/tools/policytool/i18n.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/security/tools/policytool/i18n.sh Tue May 05 18:07:05 2015 -0700
@@ -49,7 +49,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1299,8 +1299,8 @@
NULL=/dev/null
PS=":"
FS="/"
---- ./jdk/test/sun/tools/common/CommonSetup.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/tools/common/CommonSetup.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/tools/common/CommonSetup.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/tools/common/CommonSetup.sh Tue May 05 18:07:05 2015 -0700
@@ -47,6 +47,7 @@
# isLinux - true if OS is Linux
# isSolaris - true if OS is Solaris
@@ -1328,8 +1328,8 @@
Darwin )
OS="Mac OS X"
isMacos=true
---- ./jdk/test/sun/tools/jconsole/ResourceCheckTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/tools/jconsole/ResourceCheckTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/tools/jconsole/ResourceCheckTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/tools/jconsole/ResourceCheckTest.sh Tue May 05 18:07:05 2015 -0700
@@ -54,7 +54,7 @@
OS=`uname -s`
@@ -1339,8 +1339,8 @@
PATHSEP=":"
;;
---- ./jdk/test/sun/tools/native2ascii/resources/ImmutableResourceTest.sh Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/sun/tools/native2ascii/resources/ImmutableResourceTest.sh Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/sun/tools/native2ascii/resources/ImmutableResourceTest.sh Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/sun/tools/native2ascii/resources/ImmutableResourceTest.sh Tue May 05 18:07:05 2015 -0700
@@ -56,7 +56,7 @@
OS=`uname -s`
@@ -1350,8 +1350,8 @@
PATHSEP=":"
;;
---- ./jdk/test/tools/launcher/ExecutionEnvironment.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/tools/launcher/ExecutionEnvironment.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/tools/launcher/ExecutionEnvironment.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/tools/launcher/ExecutionEnvironment.java Tue May 05 18:07:05 2015 -0700
@@ -194,7 +194,7 @@
Map<String, String> env = new HashMap<>();
@@ -1361,8 +1361,8 @@
for (String x : LD_PATH_STRINGS) {
String pairs[] = x.split("=");
env.put(pairs[0], pairs[1]);
---- ./jdk/test/tools/launcher/RunpathTest.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/tools/launcher/RunpathTest.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/tools/launcher/RunpathTest.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/tools/launcher/RunpathTest.java Tue May 05 18:07:05 2015 -0700
@@ -69,7 +69,7 @@
}
@@ -1372,8 +1372,8 @@
RunpathTest rp = new RunpathTest();
rp.testRpath();
}
---- ./jdk/test/tools/launcher/Test7029048.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/tools/launcher/Test7029048.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/tools/launcher/Test7029048.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/tools/launcher/Test7029048.java Tue May 05 18:07:05 2015 -0700
@@ -223,7 +223,7 @@
} else if (isSolaris && passes < 9) {
throw new Exception("Test7029048: FAIL: " +
@@ -1383,8 +1383,8 @@
throw new Exception("Test7029048: FAIL: " +
"all tests did not run, expected " + 6 + " got " + passes);
} else {
---- ./jdk/test/tools/launcher/TestHelper.java Mon Feb 02 10:12:21 2015 -0800
-+++ ./jdk/test/tools/launcher/TestHelper.java Sat Mar 14 22:56:25 2015 -0700
+--- ./jdk/test/tools/launcher/TestHelper.java Tue Mar 17 00:09:12 2015 +0300
++++ ./jdk/test/tools/launcher/TestHelper.java Tue May 05 18:07:05 2015 -0700
@@ -94,6 +94,8 @@
System.getProperty("os.name", "unknown").startsWith("Linux");
static final boolean isAIX =
@@ -1394,8 +1394,8 @@
static final String LIBJVM = isWindows
? "jvm.dll"
: "libjvm" + (isMacOSX ? ".dylib" : ".so");
---- ./langtools/test/Makefile Wed Jan 28 12:08:47 2015 -0800
-+++ ./langtools/test/Makefile Sat Mar 14 10:28:47 2015 -0700
+--- ./langtools/test/Makefile Mon Mar 16 11:21:59 2015 -0700
++++ ./langtools/test/Makefile Tue May 05 18:06:51 2015 -0700
@@ -36,6 +36,14 @@
ARCH=i586
endif
@@ -1411,8 +1411,8 @@
ifeq ($(OSNAME), Darwin)
PLATFORM = bsd
JT_PLATFORM = linux
---- ./langtools/test/tools/javah/ReadOldClass.sh Wed Jan 28 12:08:47 2015 -0800
-+++ ./langtools/test/tools/javah/ReadOldClass.sh Sat Mar 14 10:28:47 2015 -0700
+--- ./langtools/test/tools/javah/ReadOldClass.sh Mon Mar 16 11:21:59 2015 -0700
++++ ./langtools/test/tools/javah/ReadOldClass.sh Tue May 05 18:06:51 2015 -0700
@@ -43,7 +43,7 @@
# set platform-dependent variables
OS=`uname -s`
@@ -1422,8 +1422,8 @@
PS=":"
FS="/"
;;
---- ./nashorn/test/script/jfx.js Wed Jan 28 12:08:49 2015 -0800
-+++ ./nashorn/test/script/jfx.js Sat Mar 14 10:28:56 2015 -0700
+--- ./nashorn/test/script/jfx.js Mon Mar 16 11:22:08 2015 -0700
++++ ./nashorn/test/script/jfx.js Tue May 05 18:06:53 2015 -0700
@@ -93,6 +93,8 @@
f2 = new File(sb.append(fsep + "linux.png").toString());
} else if (OSInfo.getOSType() == OSType.MACOSX) {
diff --git a/java/openjdk8/files/patch-jdk-make-lib-Awt2dLibraries.gmk b/java/openjdk8/files/patch-jdk-make-lib-Awt2dLibraries.gmk
index 679ce886e7ad..569229ba5a28 100644
--- a/java/openjdk8/files/patch-jdk-make-lib-Awt2dLibraries.gmk
+++ b/java/openjdk8/files/patch-jdk-make-lib-Awt2dLibraries.gmk
@@ -21,7 +21,7 @@
# Solaris still uses OPENWIN_LIB ..
LIBSPLASHSCREEN_LDFLAGS_SUFFIX += -L$(OPENWIN_LIB)$(OPENJDK_TARGET_CPU_ISADIR) -lX11 -lXext $(LIBM) -lpthread
else ifeq ($(OPENJDK_TARGET_OS), bsd)
-- LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(X_LIBS) -lX11 -lXext $(LIBM) -liconv -pthread
+- LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(X_LIBS) -lX11 -lXext $(LIBM) -pthread
+ LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(X_LIBS) -lX11 -lXext $(LIBM) %%ICONV_LDFLAGS%% -pthread
else # .. all other Unixes can use X_LIBS
LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(X_LIBS) -lX11 -lXext $(LIBM) -lpthread
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-17 11:11:19 +0000